Upload data/dataset_Organoid.csv with huggingface_hub

data/dataset_Organoid.csv

@@ -0,0 +1,1750 @@
+"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language"
+"Organoid","HelmholtzAI-Consultants-Munich/napari-organoid-counter","napari_organoid_counter/settings.py",".py","2277","56","from pathlib import Path
+
+def init():
+    
+    global MODELS
+    MODELS = {
+        ""faster r-cnn"": {""filename"": ""faster-rcnn_r50_fpn_organoid_best_coco_bbox_mAP_epoch_68.pth"", 
+                         ""source"": ""https://zenodo.org/records/11388549/files/faster-rcnn_r50_fpn_organoid_best_coco_bbox_mAP_epoch_68.pth""
+                         },
+        ""ssd"": {""filename"": ""ssd_organoid_best_coco_bbox_mAP_epoch_86.pth"", 
+                ""source"": ""https://zenodo.org/records/11388549/files/ssd_organoid_best_coco_bbox_mAP_epoch_86.pth""
+                },
+        ""yolov3"": {""filename"": ""yolov3_416_organoid_best_coco_bbox_mAP_epoch_27.pth"",
+                   ""source"": ""https://zenodo.org/records/11388549/files/yolov3_416_organoid_best_coco_bbox_mAP_epoch_27.pth""
+                   },
+        ""rtmdet"":  {""filename"": ""rtmdet_l_organoid_best_coco_bbox_mAP_epoch_323.pth"",
+                    ""source"": ""https://zenodo.org/records/11388549/files/rtmdet_l_organoid_best_coco_bbox_mAP_epoch_323.pth""
+                    },
+    }
+    
+    global MODELS_DIR
+    MODELS_DIR = Path.home() / "".cache/napari-organoid-counter/models""
+
+    global MODEL_TYPE
+    MODEL_TYPE = '.pth'
+
+    global CONFIGS
+    CONFIGS = {
+        ""faster r-cnn"": {""source"": ""https://zenodo.org/records/11388549/files/faster-rcnn_r50_fpn_organoid.py"",
+                        ""destination"": "".mim/configs/faster_rcnn/faster-rcnn_r50_fpn_organoid.py""
+                        },
+        ""ssd"": {""source"": ""https://zenodo.org/records/11388549/files/ssd_organoid.py"",
+                ""destination"": "".mim/configs/ssd/ssd_organoid.py""
+                },
+        ""yolov3"": {""source"": ""https://zenodo.org/records/11388549/files/yolov3_416_organoid.py"",
+                ""destination"": "".mim/configs/yolo/yolov3_416_organoid.py""
+                },
+        ""rtmdet"":  {""source"": ""https://zenodo.org/records/11388549/files/rtmdet_l_organoid.py"",
+                    ""destination"": "".mim/configs/rtmdet/rtmdet_l_organoid.py""
+                    }
+
+}
+    
+    # Add color definitions
+    global COLOR_CLASS_1
+    COLOR_CLASS_1 = [85 / 255, 1.0, 0, 1.0]  # Green
+    
+    global COLOR_CLASS_2
+    COLOR_CLASS_2 = [0, 29 / 255, 1.0, 1.0]  # Blue
+
+    global COLOR_DEFAULT
+    COLOR_DEFAULT = [1., 0, 1., 1.] # Magenta
+
+
+
+","Python"
+"Organoid","HelmholtzAI-Consultants-Munich/napari-organoid-counter","napari_organoid_counter/_utils.py",".py","8253","197","from contextlib import contextmanager
+import os
+from pathlib import Path
+import pkgutil
+
+import numpy as np
+import math
+import json
+import csv
+from skimage.transform import rescale
+from skimage.color import gray2rgb
+
+import torch
+from torchvision.ops import nms
+
+from napari_organoid_counter import settings
+
+
+def add_local_models():
+    """""" Checks the models directory for any local models previously added by the user.
+    If some are found then these are added to the model dictionary (see settings). """"""
+    if not os.path.exists(settings.MODELS_DIR): return
+    model_names_in_dir = [file for file in os.listdir(settings.MODELS_DIR)]
+    model_names_in_dict = [settings.MODELS[key][""filename""] for key in settings.MODELS.keys()]
+    for model_name in model_names_in_dir:
+        if model_name not in model_names_in_dict and model_name.endswith(settings.MODEL_TYPE):
+            _ = add_to_dict(model_name)
+
+def add_to_dict(filepath):
+    """""" Given the full path and name of a model in filepath the model is added to the models dict (see settings)""""""
+    filepath = Path(filepath)
+    name = filepath.name
+    stem_name = filepath.stem
+    settings.MODELS[stem_name] = {""filename"": name, ""source"": ""local""}
+    return stem_name
+
+def return_is_file(path, filename):
+    """""" Return True if the file exists in path and False otherwise """"""
+    full_path = join_paths(path, filename)
+    return os.path.isfile(full_path)
+
+def join_paths(path1, path2):
+    """""" Returns output of os.path.join """"""
+    return os.path.join(path1, path2)
+
+@contextmanager
+def set_dict_key(dictionary, key, value):
+    """""" Used to set a new value in the napari layer metadata """"""
+    dictionary[key] = value
+    yield
+    del dictionary[key]
+
+def get_diams(bbox):
+    """""" Get the lengths of the bounding boxes """"""
+    x1_real, y1_real, x2_real, y2_real = bbox
+    dx = abs(x1_real - x2_real)
+    dy = abs(y1_real - y2_real)
+    return dx, dy
+
+def write_to_json(name, data):
+    """""" Write data to a json file. Here data is a dict """"""
+    with open(name, 'w') as outfile:
+        json.dump(data, outfile)  
+
+def get_bboxes_as_dict(bboxes, bbox_ids, scores, scales, labels):
+    """""" Write all data, boxes, ids and scores, scale and class label, to a dict so we can later save as a json """"""
+    data_json = {} 
+    for idx, bbox in enumerate(bboxes):
+        x1, y1 = bbox[0]
+        x2, y2 = bbox[2]
+
+        data_json.update({str(bbox_ids[idx]): {'box_id': str(bbox_ids[idx]),
+                                                'x1': str(x1),
+                                                'x2': str(x2),
+                                                'y1': str(y1),
+                                                'y2': str(y2),
+                                                'confidence': str(scores[idx]),
+                                                'scale_x': str(scales[0]),
+                                                'scale_y': str(scales[1]),
+                                                'class': labels[idx]
+                                                }
+                        })
+    return data_json
+
+def write_to_csv(name, data):
+    """""" Write data to a csv file. Here data is a list of lists, where each item represents a row in the csv file. """"""
+    with open(name, 'w') as f:
+        write = csv.writer(f, delimiter=';')
+        write.writerow(['OrganoidID', 'D1[um]','D2[um]', 'Area [um^2]'])
+        write.writerows(data)
+
+def get_bbox_diameters(bboxes, bbox_ids, scales):
+    """""" Write all data, box diameters and area, ids and scale, to a list so we can later save as a csv """"""
+    data_csv = []
+    # save diameters and area of organoids (approximated as ellipses)
+    for idx, bbox in enumerate(bboxes):
+        d1 = abs(bbox[0][0] - bbox[2][0]) * scales[0]
+        d2 = abs(bbox[0][1] - bbox[2][1]) * scales[1]
+        area = math.pi * d1 * d2
+        data_csv.append([bbox_ids[idx], round(d1,3), round(d2,3), round(area,3)])
+    return data_csv
+
+def squeeze_img(img):
+    """""" Squeeze image - all dims that have size one will be removed """"""
+    return np.squeeze(img)
+
+def prepare_img(test_img, step, window_size, rescale_factor):
+    """""" The original image is prepared for running model inference """"""
+    # squeeze and resize image
+    test_img = squeeze_img(test_img)
+    test_img = rescale(test_img, rescale_factor, preserve_range=True)
+    img_height, img_width = test_img.shape
+    # pad image
+    pad_x = (img_height//step)*step + window_size - img_height
+    pad_y = (img_width//step)*step + window_size - img_width
+    test_img = np.pad(test_img, ((0, int(pad_x)), (0, int(pad_y))), mode='edge')
+    # normalise and convert to RGB - model input has size 3
+    test_img = (test_img-np.min(test_img))/(np.max(test_img)-np.min(test_img)) 
+    test_img = (255*test_img).astype(np.uint8)
+    test_img = gray2rgb(test_img) #[H,W,C]
+
+    # convert from RGB to GBR - expected from DetInferencer 
+    test_img = test_img[..., ::-1] 
+    
+    return test_img, img_height, img_width
+
+def apply_nms(bbox_preds, scores_preds, iou_thresh=0.5):
+    """""" Function applies non max suppression to iteratively remove lower scoring boxes which have an IoU greater than iou_threshold 
+    with another (higher scoring) box. The boxes and corresponding scores whihc remain are returned. """"""
+    # torchvision returns the indices of the bboxes to keep
+    keep = nms(bbox_preds, scores_preds, iou_thresh)
+    # filter existing boxes and scores and return
+    bbox_preds_kept = bbox_preds[keep]
+    scores_preds = scores_preds[keep]
+    return bbox_preds_kept, scores_preds
+
+def convert_boxes_to_napari_view(pred_bboxes):
+    """""" The bboxes are converted from tensors in model output form to a form which can be visualised in the napari viewer """"""
+    if pred_bboxes is None: return []
+    new_boxes = []
+    for idx in range(pred_bboxes.size(0)):
+        # convert to numpy and take coordinates 
+        x1_real, y1_real, x2_real, y2_real = pred_bboxes[idx].numpy()
+        # append to a list in form napari exects
+        new_boxes.append(np.array([[x1_real, y1_real],
+                                [x1_real, y2_real],
+                                [x2_real, y2_real],
+                                [x2_real, y1_real]]))
+    return new_boxes
+
+def convert_boxes_from_napari_view(pred_bboxes):
+    """""" The bboxes are converted from the form they were in the napari viewer to tensors that correspond to the model output form """"""
+    new_boxes = []
+    for idx in range(len(pred_bboxes)):
+        # read coordinates
+        x1 = pred_bboxes[idx][0][0]
+        x2 = pred_bboxes[idx][2][0]
+        y1 = pred_bboxes[idx][0][1]
+        y2 = pred_bboxes[idx][2][1]
+        # convert to tensor and append to list
+        new_boxes.append(torch.Tensor([x1, y1, x2, y2]))
+    if len(new_boxes) > 0: new_boxes = torch.stack(new_boxes)
+    return new_boxes
+
+def apply_normalization(img):
+    """""" Normalize image""""""
+    # squeeze and change dtype
+    img = squeeze_img(img)
+    img = img.astype(np.float64)
+    # adapt img to range 0-255
+    img_min = np.min(img) # 31.3125 png 0
+    img_max = np.max(img) # 2899.25 png 178
+    img_norm = (255 * (img - img_min) / (img_max - img_min)).astype(np.uint8)
+    return img_norm
+
+def get_package_init_file(package_name):
+    loader = pkgutil.get_loader(package_name)
+    if loader is None or not hasattr(loader, 'get_filename'):
+        raise ImportError(f""Cannot find package {package_name}"")
+    package_path = loader.get_filename(package_name)
+    # Determine the path to the __init__.py file
+    if os.path.isdir(package_path):
+        init_file_path = os.path.join(package_path, '__init__.py')
+    else:
+        init_file_path = package_path
+    if not os.path.isfile(init_file_path):
+        raise FileNotFoundError(f""__init__.py file not found for package {package_name}"")
+    return init_file_path
+
+def update_version_in_mmdet_init_file(package_name, old_version, new_version):
+    init_file_path = get_package_init_file(package_name)
+    with open(init_file_path, 'r') as file:
+        lines = file.readlines()
+    with open(init_file_path, 'w') as file:
+        for line in lines:
+            if f""mmcv_maximum_version = '{old_version}'"" in line:
+                file.write(line.replace(old_version, new_version))","Python"
+"Organoid","HelmholtzAI-Consultants-Munich/napari-organoid-counter","napari_organoid_counter/_reader.py",".py","2407","60","import json
+import numpy as np
+from napari import layers
+from pathlib import Path
+
+readable_extensions = '.json'
+
+def get_reader(path):
+    """""" A basic implementation of the napari_get_reader hook specification """"""
+    # if we know we cannot read the file, we immediately return None.
+    if not path.endswith(readable_extensions):
+        return None
+    # otherwise we return the *function* that can read ``path``.
+    return reader_function
+
+def reader_function(path: str) -> layers.Shapes:
+    """""" Reads the labels in the json file and adds a shapes layer to the napari viewer """"""
+    # laod json
+    f = open(path)
+    annot = json.load(f)
+    # initialise empty lists for boxes, ids and scores
+    bboxes = []
+    ids = []
+    scores = []
+    # for each box
+    for key in annot.keys():
+        # read coordinates
+        x1 = round(int(float(annot[key]['x1'])))
+        y1 = round(int(float(annot[key]['y1'])))
+        x2 = round(int(float(annot[key]['x2'])))
+        y2 = round(int(float(annot[key]['y2'])))
+        # append in style readable by napari viewer 
+        bboxes.append(np.array([[x1, y1],
+                                [x1, y2],
+                                [x2, y2],
+                                [x2, y1]]))
+        # and append scores and ids whihc will be used to display as text
+        ids.append(int(annot[key]['box_id']))
+        scores.append(float(annot[key]['confidence']))
+
+    # scale will adjust boxes according to physical resolution of image
+    scale = (float(annot[key]['scale_x']), float(annot[key]['scale_y'])) # do only once
+    # name of layer which will be created
+    labels_name = 'Labels-'+Path(path).stem
+    # properties used for dusplaying text
+    properties = {'box_id': ids,'scores': scores}
+    text_params = {'string': 'ID: {box_id}\nConf.: {scores:.2f}',
+                    'size': 12,
+                    'anchor': 'upper_left',}
+    layer_attributes = {'name': labels_name,
+                        'scale': scale,
+                        'properties': properties,
+                        'text': text_params,
+                        'face_color': 'transparent',  
+                        'edge_color': 'magenta',
+                        'shape_type': 'rectangle',
+                        'edge_width': 12
+    }
+    # return data, attributes for displaying and type of layer to add to viewer
+    return [(bboxes, layer_attributes, 'shapes')]","Python"
+"Organoid","HelmholtzAI-Consultants-Munich/napari-organoid-counter","napari_organoid_counter/_orgacount.py",".py","14778","286","from urllib.request import urlretrieve
+from napari.utils import progress
+
+from napari_organoid_counter._utils import *
+from napari_organoid_counter import settings
+
+#update_version_in_mmdet_init_file('mmdet', '2.2.0', '2.3.0')
+import torch
+import mmdet
+from mmdet.apis import DetInferencer
+
+class OrganoiDL():
+    '''
+    The back-end of the organoid counter widget
+    Attributes
+    ----------
+        device: torch.device
+            The current device, either 'cpu' or 'gpu:0'
+        cur_confidence: float
+            The confidence threshold of the model
+        cur_min_diam: float
+            The minimum diameter of the organoids
+        model: frcnn
+            The Faster R-CNN model
+        img_scale: list of floats
+            A list holding the image resolution in x and y
+        pred_bboxes: dict
+            Each key will be a set of predictions of the model, either past or current, and values will be the numpy arrays 
+            holding the predicted bounding boxes
+        pred_scores: dict
+            Each key will be a set of predictions of the model and the values will hold the confidence of the model for each
+            predicted bounding box
+        pred_ids: dict
+            Each key will be a set of predictions of the model and the values will hold the box id for each
+            predicted bounding box
+        next_id: dict
+            Each key will be a set of predictions of the model and the values will hold the next id to be attributed to a 
+            newly added box
+    '''
+    def __init__(self, handle_progress):
+        super().__init__()
+        
+        self.handle_progress = handle_progress
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.cur_confidence = 0.05
+        self.cur_min_diam = 30
+
+        self.model = None
+        self.img_scale = [0., 0.]
+        self.pred_bboxes = {}
+        self.pred_scores = {}
+        self.pred_ids = {}
+        self.next_id = {}
+
+    def set_scale(self, img_scale):
+        ''' Set the image scale: used to calculate real box sizes. '''
+        self.img_scale = img_scale
+
+    def set_model(self, model_name):
+        ''' Initialise  model instance and load model checkpoint and send to device. '''
+
+        model_checkpoint = join_paths(str(settings.MODELS_DIR), settings.MODELS[model_name][""filename""])
+        mmdet_path = os.path.dirname(mmdet.__file__)
+        config_dst = join_paths(mmdet_path, str(settings.CONFIGS[model_name][""destination""]))
+        # download the corresponding config if it doesn't exist already
+        if not os.path.exists(config_dst):
+            urlretrieve(settings.CONFIGS[model_name][""source""], config_dst, self.handle_progress)
+        self.model = DetInferencer(config_dst, model_checkpoint, self.device, show_progress=False)
+
+    def download_model(self, model_name='yolov3'):
+        ''' Downloads the model from zenodo and stores it in settings.MODELS_DIR '''
+        # specify the url of the model which is to be downloaded
+        down_url = settings.MODELS[model_name][""source""]
+        # specify save location where the file is to be saved
+        save_loc = join_paths(str(settings.MODELS_DIR), settings.MODELS[model_name][""filename""])
+        # downloading using urllib
+        urlretrieve(down_url, save_loc, self.handle_progress)
+
+    def sliding_window(self,
+                       test_img,
+                       step,
+                       window_size,
+                       rescale_factor,
+                       prepadded_height,
+                       prepadded_width,
+                       pred_bboxes=[],
+                       scores_list=[]):
+        ''' Runs sliding window inference and returns predicting bounding boxes and confidence scores for each box.
+        Inputs
+        ----------
+        test_img: Tensor of size [B, C, H, W]
+            The image ready to be given to model as input
+        step: int
+            The step of the sliding window, same in x and y
+        window_size: int
+            The sliding window size, same in x and y
+        rescale_factor: float
+            The rescaling factor by which the image has already been resized. Is 1/downsampling
+        prepadded_height: int
+            The image height before padding was applied
+        prepadded_width: int
+            The image width before padding was applied
+        pred_bboxes: list of
+            The
+        scores_list: list of
+            The
+        Outputs
+        ----------
+        pred_bboxes: list of Tensors, default is an empty list
+            The  resulting predicted boxes are appended here - if model is run at different window
+            sizes and downsampling this list will store results of all runs of the sliding window
+            so will not be empty the second, third etc. time.
+        scores_list: list of Tensor, default is an empty list
+            The  resulting confidence scores of the model for the predicted boxes are appended here 
+            Same as pred_bboxes, can be empty on first run but stores results of all runs.
+        '''
+        for i in progress(range(0, prepadded_height, step)):
+            for j in progress(range(0, prepadded_width, step)):
+                # crop
+                img_crop = test_img[i:(i+window_size), j:(j+window_size)]
+                # get predictions
+                output = self.model(img_crop)
+                preds = output['predictions'][0]['bboxes']
+                if len(preds)==0: continue
+                else:
+                    for bbox_id in range(len(preds)):
+                        y1, x1, y2, x2 = preds[bbox_id] # predictions from model will be in form x1,y1,x2,y2
+                        x1_real = torch.div(x1+i, rescale_factor, rounding_mode='floor')
+                        x2_real = torch.div(x2+i, rescale_factor, rounding_mode='floor')
+                        y1_real = torch.div(y1+j, rescale_factor, rounding_mode='floor')
+                        y2_real = torch.div(y2+j, rescale_factor, rounding_mode='floor')
+                        pred_bboxes.append(torch.Tensor([x1_real, y1_real, x2_real, y2_real]))
+                        scores_list.append(output['predictions'][0]['scores'][bbox_id])
+        return pred_bboxes, scores_list
+
+    def run(self, 
+            img, 
+            shapes_name,
+            window_sizes,
+            downsampling_sizes,   
+            window_overlap):
+        ''' Runs inference for an image at multiple window sizes and downsampling rates using sliding window ineference.
+        The results are filtered using the NMS algorithm and are then stored to dicts.
+        Inputs
+        ----------
+        img: Numpy array of size [H, W]
+            The image ready to be given to model as input
+        shapes_name: str
+            The name of the new predictions
+        window_size: list of ints
+            The sliding window size, same in x and y, if multiple sliding window will run mulitple times
+        downsampling_sizes: list of ints
+            The downsampling factor of the image, list size must match window_size
+        window_overlap: float
+            The window overlap for the sliding window inference.
+        ''' 
+        bboxes = []
+        scores = []
+        # run for all window sizes
+        for window_size, downsampling in zip(window_sizes, downsampling_sizes):
+            # compute the step for the sliding window, based on window overlap
+            rescale_factor = 1 / downsampling
+            # window size after rescaling
+            window_size = round(window_size * rescale_factor)
+            step = round(window_size * window_overlap)
+            # prepare image for model - norm, tensor, etc.
+            ready_img, prepadded_height, prepadded_width  = prepare_img(img,
+                                                                        step,
+                                                                        window_size,
+                                                                        rescale_factor)
+            # and run sliding window over whole image
+            bboxes, scores = self.sliding_window(ready_img,
+                                                 step,
+                                                 window_size,
+                                                 rescale_factor,
+                                                 prepadded_height,
+                                                 prepadded_width,
+                                                 bboxes,
+                                                 scores)
+        # stack results
+        bboxes = torch.stack(bboxes)
+        scores = torch.Tensor(scores)
+        # apply NMS to remove overlaping boxes
+        bboxes, pred_scores = apply_nms(bboxes, scores)
+        self.pred_bboxes[shapes_name] = bboxes
+        self.pred_scores[shapes_name] = pred_scores
+        num_predictions = bboxes.size(0)
+        self.pred_ids[shapes_name] = [(i+1) for i in range(num_predictions)]
+        self.next_id[shapes_name] = num_predictions+1
+
+    def apply_params(self, shapes_name, confidence, min_diameter_um):
+        """""" After results have been stored in dict this function will filter the dicts based on the confidence
+        and min_diameter_um thresholds for the given results defined by shape_name and return the filtered dicts. """"""
+        self.cur_confidence = confidence
+        self.cur_min_diam = min_diameter_um
+        pred_bboxes, pred_scores, pred_ids = self._apply_confidence_thresh(shapes_name)
+        if pred_bboxes.size(0)!=0:
+            pred_bboxes, pred_scores, pred_ids = self._filter_small_organoids(pred_bboxes, pred_scores, pred_ids)
+        pred_bboxes = convert_boxes_to_napari_view(pred_bboxes)
+        return pred_bboxes, pred_scores, pred_ids
+
+    def _apply_confidence_thresh(self, shapes_name):
+        """""" Filters out results of shapes_name based on the current confidence threshold. """"""
+        if shapes_name not in self.pred_bboxes.keys(): return torch.empty((0))
+        keep = (self.pred_scores[shapes_name]>self.cur_confidence).nonzero(as_tuple=True)[0]
+        result_bboxes = self.pred_bboxes[shapes_name][keep]
+        result_scores = self.pred_scores[shapes_name][keep]
+        result_ids = [self.pred_ids[shapes_name][int(i)] for i in keep.tolist()]
+        return result_bboxes, result_scores, result_ids
+    
+    def _filter_small_organoids(self, pred_bboxes, pred_scores, pred_ids):
+        """""" Filters out small result boxes of shapes_name based on the current min diameter size. """"""
+        if pred_bboxes is None: return None
+        if len(pred_bboxes)==0: return None
+        min_diameter_x = self.cur_min_diam / self.img_scale[0]
+        min_diameter_y = self.cur_min_diam / self.img_scale[1]
+        keep = []
+        for idx in range(len(pred_bboxes)):
+            dx, dy = get_diams(pred_bboxes[idx])
+            if (dx >= min_diameter_x and dy >= min_diameter_y) or pred_scores[idx] == 1: keep.append(idx) 
+        pred_bboxes = pred_bboxes[keep]
+        pred_scores = pred_scores[keep]
+        pred_ids = [pred_ids[i] for i in keep]
+        return pred_bboxes, pred_scores, pred_ids
+
+    def update_bboxes_scores(self, shapes_name, new_bboxes, new_scores, new_ids):
+        ''' Updated the results dicts, self.pred_bboxes, self.pred_scores and self.pred_ids with new results.
+        If the shapes name doesn't exist as a key in the dicts the results are added with the new key. If the
+        key exists then new_bboxes, new_scores and new_ids are compared to the class result dicts and the dicts 
+        are updated, either by adding some box (user added box) or removing some box (user deleted a prediction).'''
+        
+        new_bboxes = convert_boxes_from_napari_view(new_bboxes)
+        new_scores =  torch.Tensor(list(new_scores))
+        new_ids = list(new_ids)
+        # if run hasn't been run
+        if shapes_name not in self.pred_bboxes.keys():
+            self.pred_bboxes[shapes_name] = new_bboxes
+            self.pred_scores[shapes_name] = new_scores
+            self.pred_ids[shapes_name] = new_ids
+            self.next_id[shapes_name] = len(new_ids)+1
+
+        elif len(new_ids)==0: return
+
+        else:
+            min_diameter_x = self.cur_min_diam / self.img_scale[0]
+            min_diameter_y = self.cur_min_diam / self.img_scale[1]
+            # find ids that do are not in self.pred_ids but are in new_ids
+            added_box_ids = list(set(new_ids).difference(self.pred_ids[shapes_name]))
+            if len(added_box_ids) > 0:
+                added_ids = [new_ids.index(box_id) for box_id in added_box_ids]
+                #  and add them
+                self.pred_bboxes[shapes_name] = torch.cat((self.pred_bboxes[shapes_name], new_bboxes[added_ids]))
+                self.pred_scores[shapes_name] = torch.cat((self.pred_scores[shapes_name], new_scores[added_ids]))
+                new_ids_to_add = [new_ids[i] for i in added_ids]
+                self.pred_ids[shapes_name].extend(new_ids_to_add)
+            
+            # and find ids that are in self.pred_ids and not in new_ids
+            potential_removed_box_ids = list(set(self.pred_ids[shapes_name]).difference(new_ids))
+            if len(potential_removed_box_ids) > 0:
+                potential_removed_ids = [self.pred_ids[shapes_name].index(box_id) for box_id in potential_removed_box_ids]
+                remove_ids = []
+                for idx in potential_removed_ids:
+                    dx, dy  = get_diams(self.pred_bboxes[shapes_name][idx])
+                    if self.pred_scores[shapes_name][idx] > self.cur_confidence and dx > min_diameter_x and dy > min_diameter_y:
+                        remove_ids.append(idx)
+                # and remove them
+                for idx in reversed(remove_ids):
+                    self.pred_bboxes[shapes_name] = torch.cat((self.pred_bboxes[shapes_name][:idx, :], self.pred_bboxes[shapes_name][idx+1:, :]))
+                    self.pred_scores[shapes_name] = torch.cat((self.pred_scores[shapes_name][:idx], self.pred_scores[shapes_name][idx+1:]))
+                    new_pred_ids = self.pred_ids[shapes_name][:idx]
+                    new_pred_ids.extend(self.pred_ids[shapes_name][idx+1:])
+                    self.pred_ids[shapes_name] = new_pred_ids
+
+    def update_next_id(self, shapes_name, c=0):
+        """""" Updates the next id to append to result dicts. If input c is given then that will be the next id. """"""
+        if c!=0:
+            self.next_id[shapes_name] = c
+        else: self.next_id[shapes_name] += 1
+
+    def remove_shape_from_dict(self, shapes_name):
+        """""" Removes results of shapes_name from all result dicts. """"""
+        del self.pred_bboxes[shapes_name]
+        del self.pred_scores[shapes_name]
+        del self.pred_ids[shapes_name]
+        del self.next_id[shapes_name]
+","Python"
+"Organoid","HelmholtzAI-Consultants-Munich/napari-organoid-counter","napari_organoid_counter/__init__.py",".py","178","8","try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = ""unknown""
+
+from ._widget import OrganoidCounterWidget
+from ._reader import get_reader
+","Python"
+"Organoid","HelmholtzAI-Consultants-Munich/napari-organoid-counter","napari_organoid_counter/_widget.py",".py","49792","995","from typing import List
+
+from skimage.io import imsave
+from datetime import datetime
+
+import napari
+
+from napari import layers
+from napari.utils.notifications import show_info, show_error, show_warning
+
+import numpy as np
+
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QWidget, QVBoxLayout, QApplication, QDialog, QFileDialog, QGroupBox, QHBoxLayout, QLabel, QComboBox, QPushButton, QLineEdit, QProgressBar, QSlider
+
+from napari_organoid_counter._orgacount import OrganoiDL
+from napari_organoid_counter import _utils as utils
+from napari_organoid_counter import settings
+
+import warnings
+warnings.filterwarnings(""ignore"")
+
+
+class OrganoidCounterWidget(QWidget):
+    '''
+    The main widget of the organoid counter
+    Parameters
+    ----------
+        napari_viewer: string
+            The current napari viewer
+        window_sizes: list of ints, default [1024]
+            A list with the sizes of the windows on which the model will be run. If more than one window_size is given then the model will run on several window sizes and then 
+            combine the results
+        downsampling:list of ints, default [2]
+            A list with the sizes of the downsampling ratios for each window size. List size must be the same as the window_sizes list
+        min_diameter: int, default 30
+            The minimum organoid diameter given in um
+        confidence: float, default 0.8
+            The model confidence threhsold - equivalent to box_score_thresh of faster_rcnn
+    Attributes
+    ----------
+        model_name: str
+            The name of the model user has selected
+        image_layer_names: list of strings
+            Will hold the names of all the currently open images in the viewer
+        image_layer_name: string
+            The image we are currently working on
+        shape_layer_names: list of strings
+            Will hold the names of all the currently open images in the viewer
+        save_layer_name: string
+            The name of the shapes layer that has been selected for saving
+        cur_shapes_name: string
+            The name of the shapes layer that has been selected for visualisation
+        cur_shapes_layer: napari.layers.Shapes
+            The current shapes layer we are working on - it's name should correspond to cur_shapes_name
+        organoiDL: OrganoiDL
+            The class in which all the computations are performed for computing and storing the organoids bounding boxes and confidence scores
+        num_organoids: int
+            The current number of organoids
+        original_images: dict
+        original_contrast: dict
+    '''
+    def __init__(self, 
+                napari_viewer,
+                window_sizes: List = [1024],
+                downsampling: List = [2],
+                window_overlap: float = 0.5,
+                min_diameter: int = 30,
+                confidence: float = 0.8):
+        super().__init__()
+
+        # assign class variables
+        self.viewer = napari_viewer 
+
+        # create cache dir for models if it doesn't exist and add any previously added local
+        # models to the model dict
+        settings.init()
+        settings.MODELS_DIR.mkdir(parents=True, exist_ok=True)
+        utils.add_local_models()
+        self.model_id = 2 # yolov3
+        self.model_name = list(settings.MODELS.keys())[self.model_id]
+        
+        # init params 
+        self.window_sizes = window_sizes
+        self.downsampling = downsampling
+        self.window_overlap = window_overlap
+        self.min_diameter = min_diameter
+        self.confidence = confidence
+
+        self.image_layer_names = []
+        self.image_layer_name = None 
+        self.shape_layer_names = []
+        self.save_layer_name = ''
+        self.cur_shapes_name = ''
+        self.cur_shapes_layer = None
+        self.num_organoids = 0
+        self.original_images = {}
+        self.original_contrast = {}
+        self.stored_confidences = {}
+        self.stored_diameters = {}
+
+        # Initialize multi_annotation_mode to False by default
+        self.multi_annotation_mode = False
+        # self.single_annotation_mode = True  # Initially, it's single annotation mode
+
+        # setup gui        
+        self.setLayout(QVBoxLayout())
+        self.layout().addWidget(self._setup_input_widget())
+        self.layout().addWidget(self._setup_output_widget())
+
+        # initialise organoidl instance
+        self.organoiDL = OrganoiDL(self.handle_progress)
+
+        # get already opened layers
+        self.image_layer_names = self._get_layer_names()
+        if len(self.image_layer_names)>0: self._update_added_image(self.image_layer_names)
+        self.shape_layer_names = self._get_layer_names(layer_type=layers.Shapes)
+        if len(self.shape_layer_names)>0: self._update_added_shapes(self.shape_layer_names)
+        # and watch for newly added images or shapes
+        self.viewer.layers.events.inserted.connect(self._added_layer)
+        self.viewer.layers.events.removed.connect(self._removed_layer)
+        self.viewer.layers.selection.events.changed.connect(self._sel_layer_changed)
+    
+        # setup flags used for changing slider and text of min diameter and confidence threshold
+        self.diameter_slider_changed = False 
+        self.confidence_slider_changed = False
+
+        # Key binding to change the edge_color of the bounding boxes to green
+        @self.viewer.bind_key('g')
+        def change_edge_color_to_green(viewer: napari.Viewer):
+            if not self.multi_annotation_mode:  # Check if single-annotation mode is active
+                show_error(""Cannot change edge color. Change to multi-annotation mode to enable this feature."")
+                return
+            if self.cur_shapes_layer is not None:  # Ensure shapes layer exists
+                selected_shapes = self.cur_shapes_layer.selected_data # Retrieves indices of shapes currently selected, returns a set 
+                if len(selected_shapes) > 0:
+                    # Modify the edge color only for the selected shapes
+                    current_edge_colors = self.cur_shapes_layer.edge_color 
+                    for idx in selected_shapes:
+                        # Save original color
+                        # if idx not in self.original_colors: 
+                            # self.original_colors[idx] = current_edge_colors[idx].copy()
+                        # Update to the new color
+                        current_edge_colors[idx] = settings.COLOR_CLASS_1
+                    self.cur_shapes_layer.edge_color = current_edge_colors  # Apply the changes
+                    show_info(f""Changed edge color of shapes {list(selected_shapes)} to green."")
+                else:
+                    show_warning(""No shapes selected to change edge color."")
+
+        # Key binding to change the edge_color of the bounding boxes to blue
+        @self.viewer.bind_key('h')
+        def change_edge_color_to_blue(viewer: napari.Viewer):
+            if not self.multi_annotation_mode:  # Check if single-annotation mode is active
+                show_error(""Cannot change edge color. Change to multi-annotation mode to enable this feature."")
+                return         
+            if self.cur_shapes_layer is not None:  # Ensure shapes layer exists
+                selected_shapes = self.cur_shapes_layer.selected_data
+                if len(selected_shapes) > 0:
+                    # Modify the edge color only for the selected shapes
+                    current_edge_colors = self.cur_shapes_layer.edge_color
+                    for idx in selected_shapes:
+                        # Save original color
+                        # if idx not in self.original_colors: 
+                            # self.original_colors[idx] = current_edge_colors[idx].copy()
+                        # Update to the new color
+                        current_edge_colors[idx] = settings.COLOR_CLASS_2
+                    self.cur_shapes_layer.edge_color = current_edge_colors  # Apply the changes
+                    show_info(f""Changed edge color of {list(selected_shapes)} to blue."")
+                else:
+                    show_warning(""No shapes selected to change edge color."")
+
+        # Key binding to reset the edge_color of selected bounding boxes to the original magenta color
+        @self.viewer.bind_key('m')
+        def change_to_original_color(viewer: napari.Viewer):
+            if not self.multi_annotation_mode:  # Check if single-annotation mode is active
+                show_info(""Cannot change edge color. Change to multi-annotation mode to enable this feature."")
+                return
+            if self.cur_shapes_layer is not None:  # Ensure shapes layer exists
+                selected_shapes = self.cur_shapes_layer.selected_data
+                if len(selected_shapes) > 0:
+                    current_edge_colors = self.cur_shapes_layer.edge_color
+                    # Modify the edge color only for the selected shapes
+                    current_edge_colors = self.cur_shapes_layer.edge_color
+                    for idx in selected_shapes:
+                        # if idx in self.original_colors:
+                            # Revert to the original color
+                            current_edge_colors[idx] = settings.COLOR_DEFAULT
+                    self.cur_shapes_layer.edge_color = current_edge_colors  # Apply the changes
+                    show_info(f""Reset edge color of {list(selected_shapes)} to magenta."")
+                else:
+                    show_warning(""No shapes selected to reset edge color."")
+
+
+    def handle_progress(self, blocknum, blocksize, totalsize):
+        """""" When the model is being downloaded, this method is called and th progress of the download
+        is calculated and displayed on the progress bar. This function was re-implemented from:
+        https://www.geeksforgeeks.org/pyqt5-how-to-automate-progress-bar-while-downloading-using-urllib/ """"""
+        read_data = blocknum * blocksize # calculate the progress
+        if totalsize > 0:
+            download_percentage = read_data * 100 / totalsize
+            self.progress_bar.setValue(int(download_percentage))
+            QApplication.processEvents()
+
+    def _sel_layer_changed(self, event):
+        """""" Is called whenever the user selects a different layer to work on. """"""
+        cur_layer_list = list(self.viewer.layers.selection)
+        if len(cur_layer_list)==0: return
+        cur_seg_selected = cur_layer_list[-1]
+        # switch to values of other shapes layer if clicked
+        if type(cur_seg_selected)==layers.Shapes:
+            if self.cur_shapes_layer is not None:
+                self.stored_confidences[self.cur_shapes_name] = self.confidence_slider.value()/100
+                self.stored_diameters[self.cur_shapes_name] = self.min_diameter_slider.value()
+            self.cur_shapes_layer = cur_seg_selected
+            self.cur_shapes_name = cur_seg_selected.name
+            # update min diameter text and slider with previous value of that layer
+            self.min_diameter = self.stored_diameters[self.cur_shapes_name]
+            self.min_diameter_textbox.setText(str(self.min_diameter))
+            # update confidence text and slider with previous value of that layer
+            self.confidence = self.stored_confidences[self.cur_shapes_name]
+            self.confidence_textbox.setText(str(self.confidence))
+
+    def _added_layer(self, event):
+        # get names of added layers, image and shapes
+        new_image_layer_names = self._get_layer_names()
+        new_shape_layer_names = self._get_layer_names(layer_type=layers.Shapes)
+        new_image_layer_names = [name for name in new_image_layer_names if name not in self.image_layer_names]
+        new_shape_layer_names = [name for name in new_shape_layer_names if name not in self.shape_layer_names]
+        if len(new_image_layer_names)>0 : 
+            self._update_added_image(new_image_layer_names)
+            self.image_layer_names.extend(new_image_layer_names)
+        if len(new_shape_layer_names)>0:
+            self._update_added_shapes(new_shape_layer_names)
+            self.shape_layer_names.extend(new_shape_layer_names)
+            
+    def _removed_layer(self, event):
+        """""" Is called whenever a layer has been deleted (by the user) and removes the layer from GUI and backend. """"""
+        new_image_layer_names = self._get_layer_names()
+        new_shape_layer_names = self._get_layer_names(layer_type=layers.Shapes)
+        removed_image_layer_names = [name for name in self.image_layer_names if name not in new_image_layer_names]
+        removed_shape_layer_names = [name for name in self.shape_layer_names if name not in new_shape_layer_names]
+        if len(removed_image_layer_names)>0:
+            self._update_removed_image(removed_image_layer_names)
+            self.image_layer_names = new_image_layer_names
+        if len(removed_shape_layer_names)>0:
+            self._update_remove_shapes(removed_shape_layer_names)
+            self.shape_layer_names = new_shape_layer_names
+
+    def _preprocess(self):
+        """""" Preprocess the current image in the viewer to improve visualisation for the user """"""
+        img = self.original_images[self.image_layer_name]
+        img = utils.apply_normalization(img)
+        self.viewer.layers[self.image_layer_name].data = img
+        self.viewer.layers[self.image_layer_name].contrast_limits = (0,255)
+
+    def _update_num_organoids(self, len_bboxes):
+        """""" Updates the number of organoids displayed in the viewer """"""
+        self.num_organoids = len_bboxes
+        new_text = 'Number of organoids: '+str(self.num_organoids)
+        self.organoid_number_label.setText(new_text)
+
+    def _update_vis_bboxes(self, bboxes, scores, box_ids, labels_layer_name):
+        """""" Adds the shapes layer to the viewer or updates it if already there """"""
+        self._update_num_organoids(len(bboxes))
+        # if layer already exists
+        if labels_layer_name in self.shape_layer_names: 
+            self.viewer.layers[labels_layer_name].data = bboxes # hack to get edge_width stay the same!
+            self.viewer.layers[labels_layer_name].properties = {'box_id': box_ids,'scores': scores}
+            self.viewer.layers[labels_layer_name].edge_width = 12
+            self.viewer.layers[labels_layer_name].refresh()
+            self.viewer.layers[labels_layer_name].refresh_text()
+        # or if this is the first run
+        else:
+            # if no organoids were found just make an empty shapes layer
+            if self.num_organoids==0: 
+                self.cur_shapes_layer = self.viewer.add_shapes(name=labels_layer_name,
+                                                               properties={'box_id': [],'scores': []})
+            # otherwise make the layer and add the boxes
+            else:
+                properties = {'box_id': box_ids,'scores': scores}
+                text_params = {'string': 'ID: {box_id}\nConf.: {scores:.2f}',
+                               'size': 12,
+                               'anchor': 'upper_left',}
+                self.cur_shapes_layer = self.viewer.add_shapes(bboxes, 
+                                                               name=labels_layer_name,
+                                                               scale=self.viewer.layers[self.image_layer_name].scale,
+                                                               face_color='transparent',  
+                                                               properties = properties,
+                                                               text = text_params,
+                                                               edge_color=settings.COLOR_DEFAULT,
+                                                               shape_type='rectangle',
+                                                               edge_width=12) # warning generated here
+                            
+            # set current_edge_width so edge width is the same when users annotate - doesnt' fix new preds being added!
+            self.viewer.layers[labels_layer_name].current_edge_width = 12
+            
+
+    def _on_preprocess_click(self):
+        """""" Is called whenever preprocess button is clicked """"""
+        if not self.image_layer_name: show_info('Please load an image first and try again!')
+        else: self._preprocess()
+
+    def _on_run_click(self):
+        """""" Is called whenever Run Organoid Counter button is clicked """"""
+        # check if an image has been loaded
+        if not self.image_layer_name: 
+            show_info('Please load an image first and try again!')
+            return
+        # check if model exists locally and if not ask user if it's ok to download
+        if not utils.return_is_file(settings.MODELS_DIR, settings.MODELS[self.model_name][""filename""]): 
+            confirm_window = ConfirmUpload(self)
+            confirm_window.exec_()
+            # if user clicks cancel return doing nothing 
+            if confirm_window.result() != QDialog.Accepted: return
+            # otherwise donwload model and display progress in progress bar
+            else: 
+                self.progress_box.show()
+                self.organoiDL.download_model(self.model_name)
+                self.progress_box.hide()
+        
+        # load model checkpoint
+        self.organoiDL.set_model(self.model_name)
+        if self.organoiDL.img_scale[0]==0: self.organoiDL.set_scale(self.viewer.layers[self.image_layer_name].scale)
+        
+        # make sure the number of windows and downsamplings are the same
+        if len(self.window_sizes) != len(self.downsampling): 
+            show_info('Keep number of window sizes and downsampling the same and try again!')
+            return
+        
+        # get the current image 
+        img_data = self.viewer.layers[self.image_layer_name].data
+        
+        # check that image is grayscale
+        if len(utils.squeeze_img(img_data).shape) > 2:
+            show_info('Only grayscale images currently supported. Try a different image or process it first and try again!')
+            return 
+        
+        # update the viewer with the new bboxes
+        labels_layer_name = 'Labels-'+self.image_layer_name
+        if labels_layer_name in self.shape_layer_names:
+            show_info('Found existing labels layer. Please remove or rename it and try again!')
+            return 
+        
+        # show activity docker for progrgess bar while running 
+        self.viewer.window._status_bar._toggle_activity_dock(True)
+       
+        # run inference
+        self.organoiDL.run(img_data, 
+                           labels_layer_name,
+                           self.window_sizes,
+                           self.downsampling,
+                           self.window_overlap)
+        
+        # set the confidence threshold, remove small organoids and get bboxes in format o visualise
+        bboxes, scores, box_ids = self.organoiDL.apply_params(labels_layer_name, self.confidence, self.min_diameter)
+        # hide activcity dock on completion
+        self.viewer.window._status_bar._toggle_activity_dock(False)
+        # update widget with results
+        self._update_vis_bboxes(bboxes, scores, box_ids, labels_layer_name)
+        # and update cur_shapes_name to newly created shapes layer
+        self.cur_shapes_name = labels_layer_name
+        # preprocess the image if not done so already to improve visualisation
+        self._preprocess() 
+
+    def _on_model_selection_changed(self):
+        """""" Is called when user selects a new model from the dropdown menu. """"""
+        self.model_name = self.model_selection.currentText()
+
+    def _on_choose_model_clicked(self):
+        """""" Is called whenever browse button is clicked for model selection """"""
+        # called when the user hits the 'browse' button to select a model
+        fd = QFileDialog()
+        fd.setFileMode(QFileDialog.AnyFile)
+        if fd.exec_():
+            model_path = fd.selectedFiles()[0]
+        import shutil
+        shutil.copy2(model_path, settings.MODELS_DIR)
+        model_name = utils.add_to_dict(model_path)
+        self.model_selection.addItem(model_name)
+
+    def _on_window_sizes_changed(self):
+        """""" Is called whenever user changes the window sizes text box """"""
+        new_window_sizes = self.window_sizes_textbox.text()
+        new_window_sizes = new_window_sizes.split(',')
+        self.window_sizes = [int(win_size) for win_size in new_window_sizes]
+
+    def _on_downsampling_changed(self):
+        """""" Is called whenever user changes the downsampling text box """"""
+        new_downsampling = self.downsampling_textbox.text()
+        new_downsampling = new_downsampling.split(',')
+        self.downsampling = [int(ds) for ds in new_downsampling]
+
+    def _rerun(self):
+        """""" Is called whenever user changes one of the two parameter sliders """"""
+        # check if OrganoiDL instance exists - create it if not and set there current boxes, scores and ids        
+        if self.organoiDL.img_scale[0]==0: self.organoiDL.set_scale(self.cur_shapes_layer.scale)
+        self.organoiDL.update_next_id(self.cur_shapes_name, len(self.cur_shapes_layer.scale)+1)
+        
+        # make sure to add info to cur_shapes_layer.metadata to differentiate this action from when user adds/removes boxes
+        with utils.set_dict_key( self.cur_shapes_layer.metadata, 'napari-organoid-counter:_rerun', True):
+            # first update bboxes in organoiDLin case user has added/removed
+            self.organoiDL.update_bboxes_scores(self.cur_shapes_name,
+                                                self.cur_shapes_layer.data, 
+                                                self.cur_shapes_layer.properties['scores'],
+                                                self.cur_shapes_layer.properties['box_id'])
+            # and get new boxes, scores and box ids based on new confidence and min_diameter values 
+            bboxes, scores, box_ids = self.organoiDL.apply_params(self.cur_shapes_name, self.confidence, self.min_diameter)
+            self._update_vis_bboxes(bboxes, scores, box_ids, self.cur_shapes_name)
+
+    def _on_diameter_slider_changed(self):
+        """""" Is called whenever user changes the Minimum Diameter slider """"""
+        # get current value
+        self.min_diameter = self.min_diameter_slider.value()
+        self.diameter_slider_changed = True
+        if int(self.min_diameter_textbox.text())!= self.min_diameter:
+            self.min_diameter_textbox.setText(str(self.min_diameter))
+        self.diameter_slider_changed = False
+        # check if no labels loaded yet
+        if len(self.shape_layer_names)==0: return
+        self._rerun() 
+    
+    def _on_diameter_textbox_changed(self):
+        """""" Is called whenever user changes the minimum diameter from the textbox """"""
+        # check if no labels loaded yet
+        if self.diameter_slider_changed: return
+        self.min_diameter = int(self.min_diameter_textbox.text())
+        if self.min_diameter_slider.value() != self.min_diameter:
+            self.min_diameter_slider.setValue(self.min_diameter)
+        if len(self.shape_layer_names)==0: return
+        self._rerun()
+
+    def _on_confidence_slider_changed(self):
+        """""" Is called whenever user changes the confidence slider """"""
+        self.confidence = self.confidence_slider.value()/100
+        self.confidence_slider_changed = True
+        if float(self.confidence_textbox.text()) != self.confidence:
+            self.confidence_textbox.setText(str(self.confidence))
+        self.confidence_slider_changed = False
+        # check if no labels loaded yet
+        if len(self.shape_layer_names)==0: return
+        self._rerun()
+
+    def _on_confidence_textbox_changed(self):
+        """""" Is called whenever user changes the confidence value from the textbox """"""
+        if self.confidence_slider_changed: return
+        self.confidence = float(self.confidence_textbox.text())
+        slider_conf_value = int(self.confidence*100)
+        if self.confidence_slider.value() != slider_conf_value:
+            self.confidence_slider.setValue(slider_conf_value)
+        if len(self.shape_layer_names)==0: return
+        self._rerun()
+
+    def _on_image_selection_changed(self):
+        """""" Is called whenever a new image has been selected from the drop down box """"""
+        self.image_layer_name = self.image_layer_selection.currentText()
+    
+    def _on_shapes_selection_changed(self):
+        """""" Is called whenever a new shapes layer has been selected from the drop down box """"""
+        self.save_layer_name = self.output_layer_selection.currentText()
+
+    def _on_reset_click(self):
+        """""" Is called whenever Reset Configs button is clicked """"""
+        # reset params
+        self.min_diameter = 30
+        self.confidence = 0.8
+        vis_confidence = int(self.confidence*100)
+        self.min_diameter_slider.setValue(self.min_diameter)
+        self.confidence_slider.setValue(vis_confidence)
+        if self.image_layer_name:
+            # reset to original image
+            self.viewer.layers[self.image_layer_name].data = self.original_images[self.image_layer_name]
+            self.viewer.layers[self.image_layer_name].contrast_limits = self.original_contrast[self.image_layer_name]
+
+    def _on_screenshot_click(self):
+        """""" Is called whenever Take Screenshot button is clicked """"""
+        screenshot=self.viewer.screenshot()
+        if not self.image_layer_name: potential_name = datetime.now().strftime(""%d%m%Y%H%M%S"")+'screenshot.png'
+        else: potential_name = self.image_layer_name+datetime.now().strftime(""%d%m%Y%H%M%S"")+'_screenshot.png'
+        fd = QFileDialog()
+        name,_ = fd.getSaveFileName(self, 'Save File', potential_name, 'Image files (*.png);;(*.tiff)') #, 'CSV Files (*.csv)')
+        if name: imsave(name, screenshot)
+
+    def on_annotation_mode_changed(self, index):
+        """"""Callback for dropdown selection.""""""
+        if index == 0:  # Single Annotation
+            self.multi_annotation_mode = False
+            # self.single_annotation_mode = True
+            show_info(""Switched to Single Annotation mode."")
+        elif index == 1:  # Multi Annotation
+            self.multi_annotation_mode = True
+            # self.single_annotation_mode = False
+            show_info(""Switched to Multi Annotation mode."")
+
+    def _on_save_csv_click(self): 
+        """""" Is called whenever Save features button is clicked """"""
+        bboxes = self.viewer.layers[self.save_layer_name].data
+        if not bboxes: show_info('No organoids detected! Please run auto organoid counter or run algorithm first and try again!')
+        else:
+            # write diameters and area to csv
+            data_csv = utils.get_bbox_diameters(bboxes, 
+                                          self.viewer.layers[self.save_layer_name].properties['box_id'],
+                                          self.viewer.layers[self.save_layer_name].scale)
+            fd = QFileDialog()
+            name, _ = fd.getSaveFileName(self, 'Save File', self.save_layer_name, 'CSV files (*.csv)')#, 'CSV Files (*.csv)')
+            if name: utils.write_to_csv(name, data_csv)
+
+    def _on_save_json_click(self):
+        """""" Is called whenever Save boxes button is clicked """"""
+        bboxes = self.viewer.layers[self.save_layer_name].data
+        #scores = #add
+        if not bboxes: 
+            show_info('No organoids detected! Please run auto organoid counter or run algorithm first and try again!')
+            return
+        
+        # Check for multi-annotation mode
+        if self.multi_annotation_mode:
+
+            # Get the edge colors for all bounding boxes
+            edge_colors = self.cur_shapes_layer.edge_color
+            labels = []
+
+            # Check if all bounding boxes have their edge color set (not green or blue)
+            green = np.array(settings.COLOR_CLASS_1)
+            blue = np.array(settings.COLOR_CLASS_2)
+
+            all_colored = True
+            for edge_color in edge_colors:
+                # Compare the colors with a tolerance using np.allclose to account for floating-point errors
+                if not (np.allclose(edge_color[:3], green[:3]) or np.allclose(edge_color[:3], blue[:3])):
+                    all_colored = False
+                    break
+
+            if not all_colored:
+                show_error('Please change the color of all bounding boxes before saving.')
+                return
+            
+            # Assign organoid label based on edge_color
+            for edge_color in edge_colors:
+                if np.allclose(edge_color[:3], green[:3]):
+                    labels.append(0)  # Label for green
+                elif np.allclose(edge_color[:3], blue[:3]):
+                    labels.append(1)  # Label for blue
+                else:
+                    raise ValueError(f""Unexpected edge color {edge_color[:3]} encountered."")
+
+        #elif self.single_annotation_mode:
+        else:
+            # Single annotation mode: all bounding boxes get a default label
+            labels = [0] * len(bboxes)  # Default label for single annotation mode
+
+        data_json = utils.get_bboxes_as_dict(bboxes, 
+                                    self.viewer.layers[self.save_layer_name].properties['box_id'],
+                                    self.viewer.layers[self.save_layer_name].properties['scores'],
+                                    self.viewer.layers[self.save_layer_name].scale,
+                                    labels=labels)
+            
+        
+        # write bbox coordinates to json
+        fd = QFileDialog()
+        name,_ = fd.getSaveFileName(self, 'Save File', self.save_layer_name, 'JSON files (*.json)')#, 'CSV Files (*.csv)')
+        if name: utils.write_to_json(name, data_json)
+
+    def _update_added_image(self, added_items):
+        """"""
+        Update the selection box with new images if images have been added and update the self.original_images and self.original_contrast dicts.
+        Set the latest added image to the current working image (self.image_layer_name)
+        """"""
+        for layer_name in added_items:
+            self.image_layer_selection.addItem(layer_name)
+            self.original_images[layer_name] = self.viewer.layers[layer_name].data
+            self.original_contrast[layer_name] = self.viewer.layers[self.image_layer_name].contrast_limits
+        self.image_layer_name = added_items[0]
+
+    def _update_removed_image(self, removed_layers):
+        """"""
+        Update the selection box by removing image names if image has been deleted and remove items from self.original_images and self.original_contrast dicts.
+        """"""
+        # update drop-down selection box and remove image from dict
+        for removed_layer in removed_layers:
+            item_id = self.image_layer_selection.findText(removed_layer)
+            self.image_layer_selection.removeItem(item_id)
+            del self.original_images[removed_layer]
+            del self.original_contrast[removed_layer]
+
+    def _update_added_shapes(self, added_items):
+        """"""
+        Update the selection box by shape layer names if it they have been added, update current working shape layer and instantiate OrganoiDL if not already there
+        """"""
+        # update the drop down box displaying shape layer names for saving
+        for layer_name in added_items:
+            self.output_layer_selection.addItem(layer_name)
+        # set the latest added shapes layer to the shapes layer that has been selected for saving and visualisation
+        self.save_layer_name = added_items[0]
+        self.cur_shapes_name = added_items[0]
+        self.cur_shapes_layer = self.viewer.layers[self.cur_shapes_name] 
+        # get the bounding box and update the displayed number of organoids
+        self._update_num_organoids(len(self.cur_shapes_layer.data)) 
+        # listen for a data change in the current shapes layer
+        self.organoiDL.update_bboxes_scores(self.cur_shapes_name,
+                                            self.cur_shapes_layer.data,
+                                            self.cur_shapes_layer.properties['scores'],
+                                            self.cur_shapes_layer.properties['box_id']
+                                            )
+        self.cur_shapes_layer.events.data.connect(self.shapes_event_handler)
+        
+    def _update_remove_shapes(self, removed_layers):
+        """"""
+        Update the selection box by removing shape layer names if it they been deleted and set 
+        """"""
+        # update selection box by removing image names if image has been deleted       
+        for removed_layer in removed_layers:
+            item_id = self.output_layer_selection.findText(removed_layer)
+            self.output_layer_selection.removeItem(item_id)
+            if removed_layer==self.cur_shapes_name: 
+                self._update_num_organoids(0)
+                self.organoiDL.remove_shape_from_dict(self.cur_shapes_name)
+
+    def shapes_event_handler(self, event):
+        """"""
+        This function will be called every time the current shapes layer data changes
+        """"""        
+        # make sure this stuff isn't done if data in the layer has been changed by the sliders - only by the users
+        key = 'napari-organoid-counter:_rerun'
+        if key in self.cur_shapes_layer.metadata: 
+            return 
+        
+        # get new ids, new boxes and update the number of organoids
+        new_ids = self.viewer.layers[self.cur_shapes_name].properties['box_id']
+        self._update_num_organoids(len(new_ids))
+        
+        # check if duplicate ids - this happens when user adds a box, currently only available fix current_properties doesn't work
+        if len(new_ids) > len(set(new_ids)):
+            num_sim = len(new_ids) - len(set(new_ids))
+            if num_sim > 1: print('this should not happen!!!!!!!!!!!!!!!!!')
+            else: 
+                new_ids[-1] = self.organoiDL.next_id[self.cur_shapes_name]
+                new_scores = self.viewer.layers[self.cur_shapes_name].properties['scores']
+                new_scores[-1] = 1
+    
+            # set new properties to shapes layer
+            self.viewer.layers[self.cur_shapes_name].properties ={'box_id': new_ids,'scores':  new_scores}
+            # refresh text displayed
+            self.viewer.layers[self.cur_shapes_name].refresh()
+            self.viewer.layers[self.cur_shapes_name].refresh_text()
+            # and update the OrganoiDL instance
+            self.organoiDL.update_next_id(self.cur_shapes_name)
+        
+        # this doesn't work!!!!
+        # the problem is that the event is called once before the drawing has been completed!!!!!!
+        #new_bboxes = self.cur_shapes_layer.data
+        #self.organoiDL.update_bboxes_scores(new_bboxes, new_scores, new_ids)
+        
+    def _setup_input_widget(self):
+        """"""
+        Sets up the GUI part which corresposnds to the input configurations
+        """"""
+        # setup all the individual boxes
+        input_box = self._setup_input_box()
+        model_box = self._setup_model_box()
+        window_sizes_box = self._setup_window_sizes_box()
+        downsampling_box = self._setup_downsampling_box()
+        run_box = self._setup_run_box()
+        annotation_mode_box = self._setup_annotation_mode_box() # Annotation mode dropdown to select single or multi-annotation
+        self._setup_progress_box()
+
+        # and add all these to the layout
+        input_widget = QGroupBox('Input configurations')
+        vbox = QVBoxLayout()
+        vbox.addLayout(input_box)
+        vbox.addLayout(model_box)
+        vbox.addLayout(window_sizes_box)
+        vbox.addLayout(downsampling_box)
+        vbox.addLayout(run_box)
+        vbox.addLayout(annotation_mode_box)  # Add the annotation dropdown
+        vbox.addWidget(self.progress_box)
+        input_widget.setLayout(vbox)
+        return input_widget
+
+    def _setup_output_widget(self):
+        """"""
+        Sets up the GUI part which corresposnds to the parameters and outputs
+        """"""
+        # setup all the individual boxes
+        self.organoid_number_label = QLabel('Number of organoids: '+str(self.num_organoids), self)
+        self.organoid_number_label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
+        # and add all these to the layout
+        output_widget = QGroupBox('Parameters and outputs')
+        vbox = QVBoxLayout()
+        vbox.addLayout(self._setup_min_diameter_box())
+        vbox.addLayout(self._setup_confidence_box() )
+        vbox.addWidget(self.organoid_number_label)
+        vbox.addLayout(self._setup_reset_box())
+        vbox.addLayout(self._setup_save_box())
+        
+        output_widget.setLayout(vbox)
+        return output_widget
+
+    def _setup_input_box(self):
+        """"""
+        Sets up the GUI part where the input image is defined
+        """"""
+        #self.input_box = QGroupBox()
+        hbox = QHBoxLayout()
+        # setup label
+        image_label = QLabel('Image: ', self)
+        image_label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
+        # setup drop down option for selecting which image to process
+        self.image_layer_selection = QComboBox()
+        if self.image_layer_names is not None:
+            for name in self.image_layer_names: self.image_layer_selection.addItem(name)
+        #self.image_layer_selection.setItemText(self.image_layer_name)
+        self.image_layer_selection.currentIndexChanged.connect(self._on_image_selection_changed)
+        # setup preprocess button to improve visualisation
+        preprocess_btn = QPushButton(""Preprocess"")
+        preprocess_btn.clicked.connect(self._on_preprocess_click)
+        # and add all these to the layout
+        hbox.addWidget(image_label, 2)
+        hbox.addWidget(self.image_layer_selection, 4)
+        hbox.addWidget(preprocess_btn, 4)
+        return hbox
+
+    def _setup_model_box(self):
+        """"""
+        Sets up the GUI part where the model is selected from a drop down menu.
+        """"""
+        hbox = QHBoxLayout()
+        # setup the label
+        model_label = QLabel('Model: ', self)
+        model_label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
+
+        # setup the browse files button
+        fileOpenButton = QPushButton('Add custom model', self)
+        fileOpenButton.show()
+        fileOpenButton.clicked.connect(self._on_choose_model_clicked)
+        
+        # setup drop down option for selecting which image to process
+        self.model_selection = QComboBox()
+        for name in settings.MODELS.keys(): self.model_selection.addItem(name)
+        self.model_selection.setCurrentIndex(self.model_id)
+        self.model_selection.currentIndexChanged.connect(self._on_model_selection_changed)
+        
+        # and add all these to the layout
+        hbox.addWidget(model_label, 2)
+        hbox.addWidget(self.model_selection, 4)
+        hbox.addWidget(fileOpenButton, 4)
+        return hbox
+
+    def _setup_window_sizes_box(self):
+        """"""
+        Sets up the GUI part where the window sizes parameters are set
+        """"""
+        #self.window_sizes_box = QGroupBox()
+        hbox = QHBoxLayout()
+        info_text = (""Typically a ratio of 512 to 1 between window size and downsampling rate will give good results, (larger window \n""
+                    ""sizes can lead to a drop in performance). Note that small window sizes will signicantly impact the runtime of the \n""
+                    ""algorithm. For organoids of different sizes consider setting multiple windows sizes. Hit Enter for the change to \n""
+                    ""take effect."")
+        # setup label
+        window_sizes_label = QLabel('Window sizes: [size1, size2, ...]', self)
+        window_sizes_label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
+        window_sizes_label.setToolTip(info_text)
+        # setup textbox
+        self.window_sizes_textbox = QLineEdit(self)
+        text = [str(window_size) for window_size in self.window_sizes]
+        text = ','.join(text)
+        self.window_sizes_textbox.setText(text)
+        self.window_sizes_textbox.returnPressed.connect(self._on_window_sizes_changed)
+        self.window_sizes_textbox.setToolTip(info_text)
+        # and add all these to the layout
+        hbox.addWidget(window_sizes_label)
+        hbox.addWidget(self.window_sizes_textbox)   
+        #self.window_sizes_box.setLayout(hbox)   
+        #self.window_sizes_box.setStyleSheet(""border: 0px"")  
+        return hbox
+    
+    def _setup_downsampling_box(self):
+        """"""
+        Sets up the GUI part where the downsampling parameters are set
+        """"""
+        #self.downsampling_box = QGroupBox()
+        hbox = QHBoxLayout()
+        info_text = (""To detect large organoids (and ignore smaller structures) you can increase the downsampling rate. \n""
+                    ""If your organoids are small and are being missed by the algorithm, consider reducing the downsampling\n""
+                    ""rate. The number of downsampling inputs should match the number of windows sizes. Hit Enter for the \n""
+                    ""change to take effect. See window sizes for more info."")
+
+        # setup label
+        downsampling_label = QLabel('Downsampling: [ds1, ds2, ...]', self)
+        downsampling_label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
+        downsampling_label.setToolTip(info_text)
+        # setup textbox
+        self.downsampling_textbox = QLineEdit(self)
+        text = [str(ds) for ds in self.downsampling]
+        text = ','.join(text)
+        self.downsampling_textbox.setText(text)
+        self.downsampling_textbox.returnPressed.connect(self._on_downsampling_changed)
+        self.downsampling_textbox.setToolTip(info_text)
+        # and add all these to the layout
+        hbox.addWidget(downsampling_label)
+        hbox.addWidget(self.downsampling_textbox) 
+        #self.downsampling_box.setLayout(hbox)
+        #self.downsampling_box.setStyleSheet(""border: 0px"") 
+        return hbox
+
+    def _setup_run_box(self):
+        """"""
+        Sets up the GUI part where the user hits the run button
+        """"""
+        hbox = QHBoxLayout()
+        hbox.addStretch(1)
+        run_btn = QPushButton(""Run Organoid Counter"")
+        run_btn.clicked.connect(self._on_run_click)
+        run_btn.setStyleSheet(""border: 0px"")
+        hbox.addWidget(run_btn)
+        hbox.addStretch(1)
+        return hbox
+    
+    def _setup_annotation_mode_box(self):
+        """"""
+        Sets up the GUI part where the annotation mode is selected.
+        """"""
+        hbox = QHBoxLayout()
+
+        # Label
+        annotation_mode_label = QLabel(""Annotation Mode:"", self)
+        hbox.addWidget(annotation_mode_label)
+
+        # Dropdown
+        self.annotation_mode_dropdown = QComboBox()
+        self.annotation_mode_dropdown.addItems([""Single Annotation"", ""Multi Annotation""])
+        self.annotation_mode_dropdown.currentIndexChanged.connect(self.on_annotation_mode_changed)
+        hbox.addWidget(self.annotation_mode_dropdown)
+        
+        return hbox
+
+    def _setup_progress_box(self):
+        """"""
+        Sets up the GUI part which appears when the model is being downloaded.
+        This should only happen once for each model whihc is then stored in cache. 
+        """"""
+        self.progress_box = QGroupBox()
+        hbox = QHBoxLayout()
+        download_label = QLabel('Downloading model progress: ', self)
+        download_label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
+        self.progress_bar = QProgressBar(self) # creating progress bar
+        hbox.addWidget(download_label)
+        hbox.addWidget(self.progress_bar)
+        self.progress_box.setLayout(hbox)
+        self.progress_box.hide()
+
+    def _setup_min_diameter_box(self):
+        """"""
+        Sets up the GUI part where the minimum diameter parameter is displayed
+        """"""
+        hbox = QHBoxLayout()
+        # setup the min diameter slider
+        self.min_diameter_slider = QSlider(Qt.Horizontal)
+        self.min_diameter_slider.setMinimum(10)
+        self.min_diameter_slider.setMaximum(100)
+        self.min_diameter_slider.setSingleStep(10)
+        self.min_diameter_slider.setValue(self.min_diameter)
+        self.min_diameter_slider.valueChanged.connect(self._on_diameter_slider_changed)
+        # setup the label
+        min_diameter_label = QLabel('Minimum Diameter [um]: ', self)
+        min_diameter_label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
+        # setup text box
+        self.min_diameter_textbox = QLineEdit(self)
+        self.min_diameter_textbox.setText(str(self.min_diameter))
+        self.min_diameter_textbox.returnPressed.connect(self._on_diameter_textbox_changed)  
+        # and add all these to the layout
+        hbox.addWidget(min_diameter_label, 4)
+        hbox.addWidget(self.min_diameter_textbox, 1)
+        hbox.addWidget(self.min_diameter_slider, 5)
+        return hbox
+
+    def _setup_confidence_box(self):
+        """"""
+        Sets up the GUI part where the confidence parameter is displayed
+        """"""
+        hbox = QHBoxLayout()
+        # setup confidence slider
+        self.confidence_slider = QSlider(Qt.Horizontal)
+        self.confidence_slider.setMinimum(5)
+        self.confidence_slider.setMaximum(100)
+        self.confidence_slider.setSingleStep(5)
+        vis_confidence = int(self.confidence*100)
+        self.confidence_slider.setValue(vis_confidence)
+        self.confidence_slider.valueChanged.connect(self._on_confidence_slider_changed)
+        # setup label
+        confidence_label = QLabel('Model confidence: ', self)
+        confidence_label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
+        # setup text box
+        self.confidence_textbox = QLineEdit(self)
+        self.confidence_textbox.setText(str(self.confidence))
+        self.confidence_textbox.returnPressed.connect(self._on_confidence_textbox_changed)  
+        # and add all these to the layout
+        hbox.addWidget(confidence_label, 3)
+        hbox.addWidget(self.confidence_textbox, 1)
+        hbox.addWidget(self.confidence_slider, 6)
+        return hbox
+
+    def _setup_reset_box(self):
+        """"""
+        Sets up the GUI part where screenshot and reset are available to the user
+        """"""
+        #self.reset_box = QGroupBox()
+        hbox = QHBoxLayout()
+        # setup button for resetting parameters
+        self.reset_btn = QPushButton(""Reset Configs"")
+        self.reset_btn.clicked.connect(self._on_reset_click)
+        # setup button for taking screenshot of current viewer
+        self.screenshot_btn = QPushButton(""Take screenshot"")
+        self.screenshot_btn.clicked.connect(self._on_screenshot_click)
+        # and add all these to the layout
+        hbox.addStretch(1)
+        hbox.addWidget(self.screenshot_btn)
+        hbox.addSpacing(15)
+        hbox.addWidget(self.reset_btn)
+        hbox.addStretch(1)
+        #self.reset_box.setLayout(hbox)
+        #self.reset_box.setStyleSheet(""border: 0px"")
+        return hbox
+
+    def _setup_save_box(self):
+        """"""
+        Sets up the GUI part where shapes layer is saved 
+        """"""
+        #self.save_box = QGroupBox()
+        hbox = QHBoxLayout()
+        # setup button for saving features
+        self.save_csv_btn = QPushButton(""Save features"")
+        self.save_csv_btn.clicked.connect(self._on_save_csv_click)
+        # setup button for saving boxes
+        self.save_json_btn = QPushButton(""Save boxes"")
+        self.save_json_btn.clicked.connect(self._on_save_json_click)
+        # setup label
+        self.save_label = QLabel('Save: ', self)
+        self.save_label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
+        # setup drop down option for selecting which shapes layer to save
+        self.output_layer_selection = QComboBox()
+        if self.shape_layer_names is not None:
+            for name in self.shape_layer_names: self.output_layer_selection.addItem(name)
+        self.output_layer_selection.currentIndexChanged.connect(self._on_shapes_selection_changed)
+        # and add all these to the layout
+        hbox.addWidget(self.save_label)
+        hbox.addSpacing(5)
+        hbox.addWidget(self.output_layer_selection)
+        hbox.addWidget(self.save_csv_btn)
+        hbox.addWidget(self.save_json_btn)
+        #self.save_box.setLayout(hbox)
+        #self.save_box.setStyleSheet(""border: 0px"")
+        return hbox
+
+    def _get_layer_names(self, layer_type: layers.Layer = layers.Image) -> List[str]:
+        """"""
+        Get a list of layer names of a given layer type.
+        """"""
+        layer_names = [layer.name for layer in self.viewer.layers if type(layer) == layer_type]
+        if layer_names: return [] + layer_names
+        else: return []
+
+
+class ConfirmUpload(QDialog):
+    '''
+    The QDialog box that appears when the user selects to run organoid counter
+    without having the selected model locally
+    Parameters
+    ----------
+        parent: QWidget
+            The parent widget, in this case an instance of OrganoidCounterWidget
+
+    '''
+    def __init__(self, parent: QWidget):
+        super().__init__(parent)
+
+        self.setWindowTitle(""Confirm Download"")
+        # setup buttons and text to be displayed
+        ok_btn = QPushButton(""OK"")
+        cancel_btn = QPushButton(""Cancel"")
+        text = (""Model not found locally. Downloading default model to \n""
+                +str(settings.MODELS_DIR)+""\n""
+                ""This will only happen once. Click ok to continue or \n""
+                ""cancel if you do not agree. You won't be able to run\n""
+                ""the organoid counter if you click cancel."")
+        # add all to layout
+        layout = QVBoxLayout()
+        layout.addWidget(QLabel(text))
+        hbox = QHBoxLayout()
+        hbox.addWidget(ok_btn)
+        hbox.addWidget(cancel_btn)
+        layout.addLayout(hbox)
+        self.setLayout(layout)
+        # connect ok and cancel buttons with accept and reject signals
+        ok_btn.clicked.connect(self.accept)
+        cancel_btn.clicked.connect(self.reject)","Python"
+"Organoid","HelmholtzAI-Consultants-Munich/napari-organoid-counter","napari_organoid_counter/_tests/__init__.py",".py","0","0","","Python"
+"Organoid","HelmholtzAI-Consultants-Munich/napari-organoid-counter","napari_organoid_counter/_tests/test_reader.py",".py","2162","67","import json
+import numpy as np
+from napari_organoid_counter import get_reader
+
+
+# tmp_path is a pytest fixture
+def test_reader(tmp_path):
+    """"""Testing the reader part of the plugin""""""
+
+    # write some fake data using your supported file format
+    my_test_file = str(tmp_path / 'myfile.json')
+    bboxes = [np.array([[2000,2000], [2000,2500], [2500,2500], [2500,2000]]),
+              np.array([[3000,3000], [3000,3500], [3500,3500], [3500,3000]])]
+
+    original_data = {
+        '1':{
+            'box_id': '1',
+            'x1': 2000,
+            'x2': 2500,
+            'y1': 2000,
+            'y2': 2500,
+            'confidence': 0.8,
+            'scale_x': 0.9,
+            'scale_y': 0.9,
+        },
+        '2':{
+            'box_id': '2',
+            'x1': 3000,
+            'x2': 3500,
+            'y1': 3000,
+            'y2': 3500,
+            'confidence': 0.85,
+            'scale_x': 0.9,
+            'scale_y': 0.9,
+        }
+    }
+    with open(my_test_file, 'w') as outfile:
+        outfile.write(json.dumps(original_data))
+
+    # try to read it back in
+    reader = get_reader(my_test_file) #reader should return [(bboxes, layer_attributes, 'shapes')]
+    assert callable(reader)
+
+    # make sure we're delivering the right format
+    layer_data_list = reader(my_test_file)
+    assert isinstance(layer_data_list, list) and len(layer_data_list) > 0 
+    layer_data_tuple = layer_data_list[0]
+    assert isinstance(layer_data_tuple, tuple) and len(layer_data_tuple)==3
+
+    # make sure it's the same as it started
+    data = layer_data_tuple[0]
+    for idx, bbox in enumerate(bboxes):
+        assert (data[idx]==bbox).all()
+
+    # and that correct attributes and layer type is set
+    attributes = layer_data_tuple[1]
+    assert attributes['name']=='Labels-myfile'
+    assert attributes['scale']==(original_data['2']['scale_x'], original_data['2']['scale_y'])
+    assert attributes['properties']['scores'][-1]==original_data['2']['confidence']
+    
+    layer_type = layer_data_tuple[2]
+    assert isinstance(layer_type, str) and layer_type=='shapes'
+
+
+def test_get_reader_pass():
+    reader = get_reader('fake.file')
+    assert reader is None","Python"
+"Organoid","HelmholtzAI-Consultants-Munich/napari-organoid-counter","napari_organoid_counter/_tests/test_utils.py",".py","7","1","# TO DO","Python"
+"Organoid","HelmholtzAI-Consultants-Munich/napari-organoid-counter","napari_organoid_counter/_tests/test_widget.py",".py","2964","77","from napari_organoid_counter import OrganoidCounterWidget
+import numpy as np
+from skimage import draw
+from napari import layers
+
+# make_napari_viewer is a pytest fixture that returns a napari viewer object
+# capsys is a pytest fixture that captures stdout and stderr output streams
+def test_organoid_counter_widget(make_napari_viewer, capsys):
+    # make viewer and add an image layer using our fixture
+    viewer = make_napari_viewer()
+    test_img = np.zeros((1000,1000))
+    x1, y1 = draw.disk((500,500), 400)
+    x2, y2 = draw.disk((400,400), 40)
+    x3, y3 = draw.disk((600,600), 10)
+    x4, y4 = draw.disk((650,400), 100)
+    test_img[x1,y1] = 3000
+    test_img[x2,y2] = 1500
+    test_img[x3,y3] = 2000
+    test_img[x4,y4] = 1000
+    viewer.add_image(test_img, name='Test')
+
+    # create our widget, passing in the viewer
+    my_widget = OrganoidCounterWidget(viewer, 
+                                      window_sizes=[500],
+                                      downsampling=[2],
+                                      window_overlap=1)
+
+    # call preprocessing - remove duplicate here?
+    my_widget._preprocess()
+    img = my_widget.viewer.layers['Test'].data
+    assert np.max(img) <= 255.
+    assert np.min(img) >= 0.
+
+    my_widget._on_preprocess_click()
+    img = my_widget.viewer.layers['Test'].data
+    assert np.max(img) <= 255.
+    assert np.min(img) >= 0.
+
+    # test that organoid counting algorithm has run and new layer with res has been added to viewer
+    my_widget.organoiDL.download_model(my_widget.model_name)
+    my_widget._on_run_click()
+    layer_names = [layer.name for layer in  my_widget.viewer.layers]
+    assert 'Labels-Test' in layer_names
+    
+    # test that class attributes are updated when user changes values from GUI
+    my_widget._on_diameter_slider_changed()
+    assert my_widget.min_diameter == my_widget.min_diameter_slider.value()
+
+    my_widget._on_image_selection_changed()
+    assert my_widget.image_layer_name == my_widget.image_layer_selection.currentText()
+
+    # test that number of organoids is updated after manual corrections
+
+    # test that reset button resets all parameters to default settings 
+    my_widget._on_reset_click()
+    assert my_widget.min_diameter==30
+    assert my_widget.min_diameter_slider.value()==30
+    assert my_widget.confidence==0.8
+    assert my_widget.confidence_slider.value()==80
+
+    #my_widget._on_screenshot_click()
+    #'''TO DO'''
+
+    #my_widget._on_save_csv_click()
+    #'''TO DO'''
+
+    #my_widget._on_save_json_click()
+    #'''TO DO'''
+
+    my_widget._get_layer_names()
+    layer_names = [layer.name for layer in my_widget.viewer.layers if type(layer)==layers.Image]
+    assert len(layer_names) == 1
+    assert layer_names[0] == 'Test'
+    my_widget._get_layer_names(layer_type=layers.Shapes)
+    layer_names = [layer.name for layer in my_widget.viewer.layers if type(layer)==layers.Shapes]
+    assert len(layer_names) == 1
+    assert layer_names[0] == 'Labels-Test'","Python"
+"Organoid","HelmholtzAI-Consultants-Munich/napari-organoid-counter","napari_organoid_counter/_tests/test_orgacount.py",".py","7","1","# TO DO","Python"