update

models/seg_post_model/cellpose/__init__.py

@@ -1 +1 @@
-from .version import version, version_str
+# from .version import version, version_str

models/seg_post_model/cellpose/__main__.py

@@ -1,272 +0,0 @@
-"""
-Copyright © 2025 Howard Hughes Medical Institute, Authored by Carsen Stringer , Michael Rariden and Marius Pachitariu.
-"""
-import os, time
-import numpy as np
-from tqdm import tqdm
-from cellpose import utils, models, io, train
-from .version import version_str
-from cellpose.cli import get_arg_parser
-
-try:
-    from cellpose.gui import gui3d, gui
-    GUI_ENABLED = True
-except ImportError as err:
-    GUI_ERROR = err
-    GUI_ENABLED = False
-    GUI_IMPORT = True
-except Exception as err:
-    GUI_ENABLED = False
-    GUI_ERROR = err
-    GUI_IMPORT = False
-    raise
-
-import logging
-
-
-def main():
-    """ Run cellpose from command line
-    """
-
-    args = get_arg_parser().parse_args()  # this has to be in a separate file for autodoc to work
-
-    if args.version:
-        print(version_str)
-        return
-
-    ######## if no image arguments are provided, run GUI or add model and exit ########
-    if len(args.dir) == 0 and len(args.image_path) == 0:
-        if args.add_model:
-            io.add_model(args.add_model)
-            return
-        else:
-            if not GUI_ENABLED:
-                print("GUI ERROR: %s" % GUI_ERROR)
-                if GUI_IMPORT:
-                    print(
-                        "GUI FAILED: GUI dependencies may not be installed, to install, run"
-                    )
-                    print("     pip install 'cellpose[gui]'")
-            else:
-                if args.Zstack:
-                    gui3d.run()
-                else:
-                    gui.run()
-            return
-
-    ############################## run cellpose on images ##############################
-    if args.verbose:
-        from .io import logger_setup
-        logger, log_file = logger_setup()
-    else:
-        print(
-            ">>>> !LOGGING OFF BY DEFAULT! To see cellpose progress, set --verbose")
-        print("No --verbose => no progress or info printed")
-        logger = logging.getLogger(__name__)
-
-
-    # find images
-    if len(args.img_filter) > 0:
-        image_filter = args.img_filter
-    else:
-        image_filter = None
-
-    device, gpu = models.assign_device(use_torch=True, gpu=args.use_gpu,
-                                        device=args.gpu_device)
-
-    if args.pretrained_model is None or args.pretrained_model == "None" or args.pretrained_model == "False" or args.pretrained_model == "0":
-        pretrained_model = "cpsam"
-        logger.warning("training from scratch is disabled, using 'cpsam' model")
-    else:
-        pretrained_model = args.pretrained_model
-
-    # Warn users about old arguments from CP3:
-    if args.pretrained_model_ortho:
-        logger.warning(
-            "the '--pretrained_model_ortho' flag is deprecated in v4.0.1+ and no longer used")
-    if args.train_size:
-        logger.warning("the '--train_size' flag is deprecated in v4.0.1+ and no longer used")
-    if args.chan or args.chan2:
-        logger.warning('--chan and --chan2 are deprecated, all channels are used by default')
-    if args.all_channels:
-        logger.warning("the '--all_channels' flag is deprecated in v4.0.1+ and no longer used")
-    if args.restore_type:
-        logger.warning("the '--restore_type' flag is deprecated in v4.0.1+ and no longer used")
-    if args.transformer:
-        logger.warning("the '--tranformer' flag is deprecated in v4.0.1+ and no longer used")
-    if args.invert:
-        logger.warning("the '--invert' flag is deprecated in v4.0.1+ and no longer used")
-    if args.chan2_restore:
-        logger.warning("the '--chan2_restore' flag is deprecated in v4.0.1+ and no longer used")
-    if args.diam_mean:
-        logger.warning("the '--diam_mean' flag is deprecated in v4.0.1+ and no longer used")
-    if args.train_size:
-        logger.warning("the '--train_size' flag is deprecated in v4.0.1+ and no longer used")
-    
-    if args.norm_percentile is not None:
-        value1, value2 = args.norm_percentile
-        normalize = {'percentile': (float(value1), float(value2))} 
-    else:
-        normalize = (not args.no_norm)
-
-    if args.save_each:
-        if not args.save_every:
-            raise ValueError("ERROR: --save_each requires --save_every")
-
-    if len(args.image_path) > 0 and args.train:
-        raise ValueError("ERROR: cannot train model with single image input")
-
-    ## Run evaluation on images
-    if not args.train:
-        _evaluate_cellposemodel_cli(args, logger, image_filter, device, pretrained_model, normalize)
-    
-    ## Train a model ##
-    else:
-        _train_cellposemodel_cli(args, logger, image_filter, device, pretrained_model, normalize)
-
-
-def _train_cellposemodel_cli(args, logger, image_filter, device, pretrained_model, normalize):
-    test_dir = None if len(args.test_dir) == 0 else args.test_dir
-    images, labels, image_names, train_probs = None, None, None, None
-    test_images, test_labels, image_names_test, test_probs = None, None, None, None
-    compute_flows = False
-    if len(args.file_list) > 0:
-        if os.path.exists(args.file_list):
-            dat = np.load(args.file_list, allow_pickle=True).item()
-            image_names = dat["train_files"]
-            image_names_test = dat.get("test_files", None)
-            train_probs = dat.get("train_probs", None)
-            test_probs = dat.get("test_probs", None)
-            compute_flows = dat.get("compute_flows", False)
-            load_files = False
-        else:
-            logger.critical(f"ERROR: {args.file_list} does not exist")
-    else:
-        output = io.load_train_test_data(args.dir, test_dir, image_filter,
-                                                args.mask_filter,
-                                                args.look_one_level_down)
-        images, labels, image_names, test_images, test_labels, image_names_test = output
-        load_files = True
-
-    # initialize model
-    model = models.CellposeModel(device=device, pretrained_model=pretrained_model)
-
-    # train segmentation model
-    cpmodel_path = train.train_seg(
-            model.net, images, labels, train_files=image_names,
-            test_data=test_images, test_labels=test_labels,
-            test_files=image_names_test, train_probs=train_probs,
-            test_probs=test_probs, compute_flows=compute_flows,
-            load_files=load_files, normalize=normalize,
-            channel_axis=args.channel_axis, 
-            learning_rate=args.learning_rate, weight_decay=args.weight_decay,
-            SGD=args.SGD, n_epochs=args.n_epochs, batch_size=args.train_batch_size,
-            min_train_masks=args.min_train_masks,
-            nimg_per_epoch=args.nimg_per_epoch,
-            nimg_test_per_epoch=args.nimg_test_per_epoch,
-            save_path=os.path.realpath(args.dir), 
-            save_every=args.save_every,
-            save_each=args.save_each,
-            model_name=args.model_name_out)[0]
-    model.pretrained_model = cpmodel_path
-    logger.info(">>>> model trained and saved to %s" % cpmodel_path)
-    return model
-
-
-def _evaluate_cellposemodel_cli(args, logger, imf, device, pretrained_model, normalize):
-    # Check with user if they REALLY mean to run without saving anything
-    if not args.train:
-        saving_something = args.save_png or args.save_tif or args.save_flows or args.save_txt
-
-    tic = time.time()
-    if len(args.dir) > 0:
-        image_names = io.get_image_files(
-                args.dir, args.mask_filter, imf=imf,
-                look_one_level_down=args.look_one_level_down)
-    else:
-        if os.path.exists(args.image_path):
-            image_names = [args.image_path]
-        else:
-            raise ValueError(f"ERROR: no file found at {args.image_path}")
-    nimg = len(image_names)
-
-    if args.savedir:
-        if not os.path.exists(args.savedir):
-            raise FileExistsError(f"--savedir {args.savedir} does not exist")
-        
-    logger.info(
-            ">>>> running cellpose on %d images using all channels" % nimg)
-
-    # handle built-in model exceptions
-    model = models.CellposeModel(device=device, pretrained_model=pretrained_model,)
-
-    tqdm_out = utils.TqdmToLogger(logger, level=logging.INFO)
-
-    channel_axis = args.channel_axis
-    z_axis = args.z_axis
-
-    for image_name in tqdm(image_names, file=tqdm_out):
-        if args.do_3D or args.stitch_threshold > 0.:
-            logger.info('loading image as 3D zstack')
-            image = io.imread_3D(image_name)
-            if channel_axis is None:
-                channel_axis = 3
-            if z_axis is None:
-                z_axis = 0
-                
-        else:
-            image = io.imread_2D(image_name)
-        out = model.eval(
-                image, 
-                diameter=args.diameter, 
-                do_3D=args.do_3D,
-                augment=args.augment, 
-                flow_threshold=args.flow_threshold,
-                cellprob_threshold=args.cellprob_threshold,
-                stitch_threshold=args.stitch_threshold, 
-                min_size=args.min_size,
-                batch_size=args.batch_size,
-                bsize=args.bsize,
-                resample=not args.no_resample,
-                normalize=normalize,
-                channel_axis=channel_axis, 
-                z_axis=z_axis,
-                anisotropy=args.anisotropy, 
-                niter=args.niter,
-                flow3D_smooth=args.flow3D_smooth)
-        masks, flows = out[:2]
-
-        if args.exclude_on_edges:
-            masks = utils.remove_edge_masks(masks)
-        if not args.no_npy:
-            io.masks_flows_to_seg(image, masks, flows, image_name,
-                                        imgs_restore=None, 
-                                        restore_type=None,
-                                        ratio=1.)
-        if saving_something:
-            suffix = "_cp_masks"
-            if args.output_name is not None: 
-                    # (1) If `savedir` is not defined, then must have a non-zero `suffix`
-                if args.savedir is None and len(args.output_name) > 0:
-                    suffix = args.output_name
-                elif args.savedir is not None and not os.path.samefile(args.savedir, args.dir):
-                        # (2) If `savedir` is defined, and different from `dir` then                              
-                        # takes the value passed as a param. (which can be empty string)
-                    suffix = args.output_name
-
-            io.save_masks(image, masks, flows, image_name,
-                                suffix=suffix, png=args.save_png,
-                                tif=args.save_tif, save_flows=args.save_flows,
-                                save_outlines=args.save_outlines,
-                                dir_above=args.dir_above, savedir=args.savedir,
-                                save_txt=args.save_txt, in_folders=args.in_folders,
-                                save_mpl=args.save_mpl)
-        if args.save_rois:
-            io.save_rois(masks, image_name)
-    logger.info(">>>> completed in %0.3f sec" % (time.time() - tic))
-
-    return model
-
-
-if __name__ == "__main__":
-    main()

models/seg_post_model/cellpose/cli.py

@@ -1,240 +0,0 @@
-"""
-Copyright © 2023 Howard Hughes Medical Institute, Authored by Carsen Stringer and Marius Pachitariu and Michael Rariden.
-"""
-
-import argparse
-
-
-def get_arg_parser():
-    """ Parses command line arguments for cellpose main function
-
-    Note: this function has to be in a separate file to allow autodoc to work for CLI.
-    The autodoc_mock_imports in conf.py does not work for sphinx-argparse sometimes,
-    see https://github.com/ashb/sphinx-argparse/issues/9#issue-1097057823
-    """
-
-    parser = argparse.ArgumentParser(description="Cellpose Command Line Parameters")
-
-    # misc settings
-    parser.add_argument("--version", action="store_true",
-                        help="show cellpose version info")
-    parser.add_argument(
-        "--verbose", action="store_true",
-        help="show information about running and settings and save to log")
-    parser.add_argument("--Zstack", action="store_true", help="run GUI in 3D mode")
-
-    # settings for CPU vs GPU
-    hardware_args = parser.add_argument_group("Hardware Arguments")
-    hardware_args.add_argument("--use_gpu", action="store_true",
-                               help="use gpu if torch with cuda installed")
-    hardware_args.add_argument(
-        "--gpu_device", required=False, default="0", type=str,
-        help="which gpu device to use, use an integer for torch, or mps for M1")
-    
-    # settings for locating and formatting images
-    input_img_args = parser.add_argument_group("Input Image Arguments")
-    input_img_args.add_argument("--dir", default=[], type=str,
-                                help="folder containing data to run or train on.")
-    input_img_args.add_argument(
-        "--image_path", default=[], type=str, help=
-        "if given and --dir not given, run on single image instead of folder (cannot train with this option)"
-    )
-    input_img_args.add_argument(
-        "--look_one_level_down", action="store_true",
-        help="run processing on all subdirectories of current folder")
-    input_img_args.add_argument("--img_filter", default=[], type=str,
-                                help="end string for images to run on")
-    input_img_args.add_argument(
-        "--channel_axis", default=None, type=int,
-        help="axis of image which corresponds to image channels")
-    input_img_args.add_argument("--z_axis", default=None, type=int,
-                                help="axis of image which corresponds to Z dimension")
-    
-    # TODO: remove deprecated in future version
-    input_img_args.add_argument(
-        "--chan", default=0, type=int, help=
-        "Deprecated in v4.0.1+, not used. ")
-    input_img_args.add_argument(
-        "--chan2", default=0, type=int, help=
-        'Deprecated in v4.0.1+, not used. ')
-    input_img_args.add_argument("--invert", action="store_true", help=
-        'Deprecated in v4.0.1+, not used. ')
-    input_img_args.add_argument(
-        "--all_channels", action="store_true", help=
-        'Deprecated in v4.0.1+, not used. ')
-
-    # model settings
-    model_args = parser.add_argument_group("Model Arguments")
-    model_args.add_argument("--pretrained_model", required=False, default="cpsam",
-                            type=str,
-                            help="model to use for running or starting training")
-    model_args.add_argument(
-        "--add_model", required=False, default=None, type=str,
-        help="model path to copy model to hidden .cellpose folder for using in GUI/CLI")
-    model_args.add_argument("--pretrained_model_ortho", required=False, default=None,
-                            type=str,
-                            help="Deprecated in v4.0.1+, not used. ")
-    
-    # TODO: remove deprecated in future version
-    model_args.add_argument("--restore_type", required=False, default=None, type=str, help=
-        'Deprecated in v4.0.1+, not used. ')
-    model_args.add_argument("--chan2_restore", action="store_true", help=
-        'Deprecated in v4.0.1+, not used. ')
-    model_args.add_argument(
-        "--transformer", action="store_true", help=
-        "use transformer backbone (pretrained_model from Cellpose3 is transformer_cp3)")
-    
-    # algorithm settings
-    algorithm_args = parser.add_argument_group("Algorithm Arguments")
-    algorithm_args.add_argument("--no_norm", action="store_true",
-                                help="do not normalize images (normalize=False)")
-    algorithm_args.add_argument(
-        '--norm_percentile',
-        nargs=2,  # Require exactly two values
-        metavar=('VALUE1', 'VALUE2'),
-        help="Provide two float values to set norm_percentile (e.g., --norm_percentile 1 99)"
-    )
-    algorithm_args.add_argument(
-        "--do_3D", action="store_true",
-        help="process images as 3D stacks of images (nplanes x nchan x Ly x Lx")
-    algorithm_args.add_argument(
-        "--diameter", required=False, default=None, type=float, help=
-        "use to resize cells to the training diameter (30 pixels)"
-    )
-    algorithm_args.add_argument(
-        "--stitch_threshold", required=False, default=0.0, type=float,
-        help="compute masks in 2D then stitch together masks with IoU>0.9 across planes"
-    )
-    algorithm_args.add_argument(
-        "--min_size", required=False, default=15, type=int,
-        help="minimum number of pixels per mask, can turn off with -1")
-    algorithm_args.add_argument(
-        "--flow3D_smooth", required=False, default=0, type=float,
-        help="stddev of gaussian for smoothing of dP for dynamics in 3D, default of 0 means no smoothing")
-    algorithm_args.add_argument(
-        "--flow_threshold", default=0.4, type=float, help=
-        "flow error threshold, 0 turns off this optional QC step. Default: %(default)s")
-    algorithm_args.add_argument(
-        "--cellprob_threshold", default=0, type=float,
-        help="cellprob threshold, default is 0, decrease to find more and larger masks")
-    algorithm_args.add_argument(
-        "--niter", default=0, type=int, help=
-        "niter, number of iterations for dynamics for mask creation, default of 0 means it is proportional to diameter, set to a larger number like 2000 for very long ROIs"
-    )
-    algorithm_args.add_argument("--anisotropy", required=False, default=1.0, type=float,
-                                help="anisotropy of volume in 3D")
-    algorithm_args.add_argument("--exclude_on_edges", action="store_true",
-                                help="discard masks which touch edges of image")
-    algorithm_args.add_argument(
-        "--augment", action="store_true",
-        help="tiles image with overlapping tiles and flips overlapped regions to augment"
-    )
-    algorithm_args.add_argument("--batch_size", default=8, type=int,
-                               help="inference batch size. Default: %(default)s")
-
-    # TODO: remove deprecated in future version
-    algorithm_args.add_argument(
-        "--no_resample", action="store_true", 
-        help="disables flows/cellprob resampling to original image size before computing masks. Using this flag will make more masks more jagged with larger diameter settings.")
-    algorithm_args.add_argument(
-        "--no_interp", action="store_true",
-        help="do not interpolate when running dynamics (was default)")
-
-    # output settings
-    output_args = parser.add_argument_group("Output Arguments")
-    output_args.add_argument(
-        "--save_png", action="store_true",
-        help="save masks as png")
-    output_args.add_argument(
-        "--save_tif", action="store_true",
-        help="save masks as tif")
-    output_args.add_argument(
-        "--output_name", default=None, type=str,
-        help="suffix for saved masks, default is _cp_masks, can be empty if `savedir` used and different of `dir`")
-    output_args.add_argument("--no_npy", action="store_true",
-                             help="suppress saving of npy")
-    output_args.add_argument(
-        "--savedir", default=None, type=str, help=
-        "folder to which segmentation results will be saved (defaults to input image directory)"
-    )
-    output_args.add_argument(
-        "--dir_above", action="store_true", help=
-        "save output folders adjacent to image folder instead of inside it (off by default)"
-    )
-    output_args.add_argument("--in_folders", action="store_true",
-                             help="flag to save output in folders (off by default)")
-    output_args.add_argument(
-        "--save_flows", action="store_true", help=
-        "whether or not to save RGB images of flows when masks are saved (disabled by default)"
-    )
-    output_args.add_argument(
-        "--save_outlines", action="store_true", help=
-        "whether or not to save RGB outline images when masks are saved (disabled by default)"
-    )
-    output_args.add_argument(
-        "--save_rois", action="store_true",
-        help="whether or not to save ImageJ compatible ROI archive (disabled by default)"
-    )
-    output_args.add_argument(
-        "--save_txt", action="store_true",
-        help="flag to enable txt outlines for ImageJ (disabled by default)")
-    output_args.add_argument(
-        "--save_mpl", action="store_true",
-        help="save a figure of image/mask/flows using matplotlib (disabled by default). "
-        "This is slow, especially with large images.")
-
-    # training settings
-    training_args = parser.add_argument_group("Training Arguments")
-    training_args.add_argument("--train", action="store_true",
-                               help="train network using images in dir")
-    training_args.add_argument("--test_dir", default=[], type=str,
-                               help="folder containing test data (optional)")
-    training_args.add_argument(
-        "--file_list", default=[], type=str, help=
-        "path to list of files for training and testing and probabilities for each image (optional)"
-    )
-    training_args.add_argument(
-        "--mask_filter", default="_masks", type=str, help=
-        "end string for masks to run on. use '_seg.npy' for manual annotations from the GUI. Default: %(default)s"
-    )
-    training_args.add_argument("--learning_rate", default=1e-5, type=float,
-                               help="learning rate. Default: %(default)s")
-    training_args.add_argument("--weight_decay", default=0.1, type=float,
-                               help="weight decay. Default: %(default)s")
-    training_args.add_argument("--n_epochs", default=100, type=int,
-                               help="number of epochs. Default: %(default)s")
-    training_args.add_argument("--train_batch_size", default=1, type=int,
-                               help="training batch size. Default: %(default)s")
-    training_args.add_argument("--bsize", default=256, type=int,
-                               help="block size for tiles. Default: %(default)s")
-    training_args.add_argument(
-        "--nimg_per_epoch", default=None, type=int,
-        help="number of train images per epoch. Default is to use all train images.")
-    training_args.add_argument(
-        "--nimg_test_per_epoch", default=None, type=int,
-        help="number of test images per epoch. Default is to use all test images.")
-    training_args.add_argument(
-        "--min_train_masks", default=5, type=int, help=
-        "minimum number of masks a training image must have to be used. Default: %(default)s"
-    )
-    training_args.add_argument("--SGD", default=0, type=int, 
-                               help="Deprecated in v4.0.1+, not used - AdamW used instead. ")
-    training_args.add_argument(
-        "--save_every", default=100, type=int,
-        help="number of epochs to skip between saves. Default: %(default)s")
-    training_args.add_argument(
-        "--save_each", action="store_true",
-        help="wether or not to save each epoch. Must also use --save_every. (default: False)")
-    training_args.add_argument(
-        "--model_name_out", default=None, type=str,
-        help="Name of model to save as, defaults to name describing model architecture. "
-        "Model is saved in the folder specified by --dir in models subfolder.")
-    
-    # TODO: remove deprecated in future version
-    training_args.add_argument(
-        "--diam_mean", default=30., type=float, help=
-        'Deprecated in v4.0.1+, not used. ')
-    training_args.add_argument("--train_size", action="store_true", help=
-        'Deprecated in v4.0.1+, not used. ')
-
-    return parser

models/seg_post_model/cellpose/denoise.py

@@ -1,1474 +0,0 @@
-"""
-Copyright © 2025 Howard Hughes Medical Institute, Authored by Carsen Stringer , Michael Rariden and Marius Pachitariu.
-"""
-import os, time, datetime
-import numpy as np
-from scipy.stats import mode
-import cv2
-import torch
-from torch import nn
-from torch.nn.functional import conv2d, interpolate
-from tqdm import trange
-from pathlib import Path
-
-import logging
-
-denoise_logger = logging.getLogger(__name__)
-
-from cellpose import transforms, utils, io
-from cellpose.core import run_net
-from cellpose.models import CellposeModel, model_path, normalize_default, assign_device
-
-MODEL_NAMES = []
-for ctype in ["cyto3", "cyto2", "nuclei"]:
-    for ntype in ["denoise", "deblur", "upsample", "oneclick"]:
-        MODEL_NAMES.append(f"{ntype}_{ctype}")
-        if ctype != "cyto3":
-            for ltype in ["per", "seg", "rec"]:
-                MODEL_NAMES.append(f"{ntype}_{ltype}_{ctype}")
-    if ctype != "cyto3":
-        MODEL_NAMES.append(f"aniso_{ctype}")
-
-criterion = nn.MSELoss(reduction="mean")
-criterion2 = nn.BCEWithLogitsLoss(reduction="mean")
-
-
-def deterministic(seed=0):
-    """ set random seeds to create test data """
-    import random
-    torch.manual_seed(seed)
-    torch.cuda.manual_seed(seed)
-    torch.cuda.manual_seed_all(seed)  # if you are using multi-GPU.
-    np.random.seed(seed)  # Numpy module.
-    random.seed(seed)  # Python random module.
-    torch.manual_seed(seed)
-    torch.backends.cudnn.benchmark = False
-    torch.backends.cudnn.deterministic = True
-
-
-def loss_fn_rec(lbl, y):
-    """ loss function between true labels lbl and prediction y """
-    loss = 80. * criterion(y, lbl)
-    return loss
-
-
-def loss_fn_seg(lbl, y):
-    """ loss function between true labels lbl and prediction y """
-    veci = 5. * lbl[:, 1:]
-    lbl = (lbl[:, 0] > .5).float()
-    loss = criterion(y[:, :2], veci)
-    loss /= 2.
-    loss2 = criterion2(y[:, 2], lbl)
-    loss = loss + loss2
-    return loss
-
-
-def get_sigma(Tdown):
-    """ Calculates the correlation matrices across channels for the perceptual loss.
-
-    Args:
-        Tdown (list): List of tensors output by each downsampling block of network.
-
-    Returns:
-        list: List of correlations for each input tensor.
-    """
-    Tnorm = [x - x.mean((-2, -1), keepdim=True) for x in Tdown]
-    Tnorm = [x / x.std((-2, -1), keepdim=True) for x in Tnorm]
-    Sigma = [
-        torch.einsum("bnxy, bmxy -> bnm", x, x) / (x.shape[-2] * x.shape[-1])
-        for x in Tnorm
-    ]
-    return Sigma
-
-
-def imstats(X, net1):
-    """
-    Calculates the image correlation matrices for the perceptual loss.
-
-    Args:
-        X (torch.Tensor): Input image tensor.
-        net1: Cellpose net.
-
-    Returns:
-        list: A list of tensors of correlation matrices.
-    """
-    _, _, Tdown = net1(X)
-    Sigma = get_sigma(Tdown)
-    Sigma = [x.detach() for x in Sigma]
-    return Sigma
-
-
-def loss_fn_per(img, net1, yl):
-    """
-    Calculates the perceptual loss function for image restoration.
-
-    Args:
-        img (torch.Tensor): Input image tensor (noisy/blurry/downsampled).
-        net1 (torch.nn.Module): Perceptual loss net (Cellpose segmentation net).
-        yl (torch.Tensor): Clean image tensor.
-
-    Returns:
-        torch.Tensor: Mean perceptual loss.
-    """
-    Sigma = imstats(img, net1)
-    sd = [x.std((1, 2)) + 1e-6 for x in Sigma]
-    Sigma_test = get_sigma(yl)
-    losses = torch.zeros(len(Sigma[0]), device=img.device)
-    for k in range(len(Sigma)):
-        losses = losses + (((Sigma_test[k] - Sigma[k])**2).mean((1, 2)) / sd[k]**2)
-    return losses.mean()
-
-
-def test_loss(net0, X, net1=None, img=None, lbl=None, lam=[1., 1.5, 0.]):
-    """
-    Calculates the test loss for image restoration tasks.
-
-    Args:
-        net0 (torch.nn.Module): The image restoration network.
-        X (torch.Tensor): The input image tensor.
-        net1 (torch.nn.Module, optional): The segmentation network for segmentation or perceptual loss. Defaults to None.
-        img (torch.Tensor, optional): Clean image tensor for perceptual or reconstruction loss. Defaults to None.
-        lbl (torch.Tensor, optional): The ground truth flows/cellprob tensor for segmentation loss. Defaults to None.
-        lam (list, optional): The weights for different loss components (perceptual, segmentation, reconstruction). Defaults to [1., 1.5, 0.].
-
-    Returns:
-        tuple: A tuple containing the total loss and the perceptual loss.
-    """
-    net0.eval()
-    if net1 is not None:
-        net1.eval()
-    loss, loss_per = torch.zeros(1, device=X.device), torch.zeros(1, device=X.device)
-
-    with torch.no_grad():
-        img_dn = net0(X)[0]
-        if lam[2] > 0.:
-            loss += lam[2] * loss_fn_rec(img, img_dn)
-        if lam[1] > 0. or lam[0] > 0.:
-            y, _, ydown = net1(img_dn)
-        if lam[1] > 0.:
-            loss += lam[1] * loss_fn_seg(lbl, y)
-        if lam[0] > 0.:
-            loss_per = loss_fn_per(img, net1, ydown)
-            loss += lam[0] * loss_per
-    return loss, loss_per
-
-
-def train_loss(net0, X, net1=None, img=None, lbl=None, lam=[1., 1.5, 0.]):
-    """
-    Calculates the train loss for image restoration tasks.
-
-    Args:
-        net0 (torch.nn.Module): The image restoration network.
-        X (torch.Tensor): The input image tensor.
-        net1 (torch.nn.Module, optional): The segmentation network for segmentation or perceptual loss. Defaults to None.
-        img (torch.Tensor, optional): Clean image tensor for perceptual or reconstruction loss. Defaults to None.
-        lbl (torch.Tensor, optional): The ground truth flows/cellprob tensor for segmentation loss. Defaults to None.
-        lam (list, optional): The weights for different loss components (perceptual, segmentation, reconstruction). Defaults to [1., 1.5, 0.].
-
-    Returns:
-        tuple: A tuple containing the total loss and the perceptual loss.
-    """
-    net0.train()
-    if net1 is not None:
-        net1.eval()
-    loss, loss_per = torch.zeros(1, device=X.device), torch.zeros(1, device=X.device)
-
-    img_dn = net0(X)[0]
-    if lam[2] > 0.:
-        loss += lam[2] * loss_fn_rec(img, img_dn)
-    if lam[1] > 0. or lam[0] > 0.:
-        y, _, ydown = net1(img_dn)
-    if lam[1] > 0.:
-        loss += lam[1] * loss_fn_seg(lbl, y)
-    if lam[0] > 0.:
-        loss_per = loss_fn_per(img, net1, ydown)
-        loss += lam[0] * loss_per
-    return loss, loss_per
-
-
-def img_norm(imgi):
-    """
-    Normalizes the input image by subtracting the 1st percentile and dividing by the difference between the 99th and 1st percentiles.
-
-    Args:
-        imgi (torch.Tensor): Input image tensor.
-
-    Returns:
-        torch.Tensor: Normalized image tensor.
-    """
-    shape = imgi.shape
-    imgi = imgi.reshape(imgi.shape[0], imgi.shape[1], -1)
-    perc = torch.quantile(imgi, torch.tensor([0.01, 0.99], device=imgi.device), dim=-1,
-                          keepdim=True)
-    for k in range(imgi.shape[1]):
-        hask = (perc[1, :, k, 0] - perc[0, :, k, 0]) > 1e-3
-        imgi[hask, k] -= perc[0, hask, k]
-        imgi[hask, k] /= (perc[1, hask, k] - perc[0, hask, k])
-    imgi = imgi.reshape(shape)
-    return imgi
-
-
-def add_noise(lbl, alpha=4, beta=0.7, poisson=0.7, blur=0.7, gblur=1.0, downsample=0.7,
-              ds_max=7, diams=None, pscale=None, iso=True, sigma0=None, sigma1=None,
-              ds=None, uniform_blur=False, partial_blur=False):
-    """Adds noise to the input image.
-
-    Args:
-        lbl (torch.Tensor): The input image tensor of shape (nimg, nchan, Ly, Lx).
-        alpha (float, optional): The shape parameter of the gamma distribution used for generating poisson noise. Defaults to 4.
-        beta (float, optional): The rate parameter of the gamma distribution used for generating poisson noise. Defaults to 0.7.
-        poisson (float, optional): The probability of adding poisson noise to the image. Defaults to 0.7.
-        blur (float, optional): The probability of adding gaussian blur to the image. Defaults to 0.7.
-        gblur (float, optional): The scale factor for the gaussian blur. Defaults to 1.0.
-        downsample (float, optional): The probability of downsampling the image. Defaults to 0.7.
-        ds_max (int, optional): The maximum downsampling factor. Defaults to 7.
-        diams (torch.Tensor, optional): The diameter of the objects in the image. Defaults to None.
-        pscale (torch.Tensor, optional): The scale factor for the poisson noise, instead of sampling. Defaults to None.
-        iso (bool, optional): Whether to use isotropic gaussian blur. Defaults to True.
-        sigma0 (torch.Tensor, optional): The standard deviation of the gaussian filter for the Y axis, instead of sampling. Defaults to None.
-        sigma1 (torch.Tensor, optional): The standard deviation of the gaussian filter for the X axis, instead of sampling. Defaults to None.
-        ds (torch.Tensor, optional): The downsampling factor for each image, instead of sampling. Defaults to None.
-
-    Returns:
-        torch.Tensor: The noisy image tensor of the same shape as the input image.
-    """
-    device = lbl.device
-    imgi = torch.zeros_like(lbl)
-    Ly, Lx = lbl.shape[-2:]
-
-    diams = diams if diams is not None else 30. * torch.ones(len(lbl), device=device)
-    #ds0 = 1 if ds is None else ds.item()
-    ds = ds * torch.ones(
-        (len(lbl),), device=device, dtype=torch.long) if ds is not None else ds
-
-    # downsample
-    ii = []
-    idownsample = np.random.rand(len(lbl)) < downsample
-    if (ds is None and idownsample.sum() > 0.) or not iso:
-        ds = torch.ones(len(lbl), dtype=torch.long, device=device)
-        ds[idownsample] = torch.randint(2, ds_max + 1, size=(idownsample.sum(),),
-                                        device=device)
-        ii = torch.nonzero(ds > 1).flatten()
-    elif ds is not None and (ds > 1).sum():
-        ii = torch.nonzero(ds > 1).flatten()
-
-    # add gaussian blur
-    iblur = torch.rand(len(lbl), device=device) < blur
-    iblur[ii] = True
-    if iblur.sum() > 0:
-        if sigma0 is None:
-            if uniform_blur and iso:
-                xr = torch.rand(len(lbl), device=device)
-                if len(ii) > 0:
-                    xr[ii] = ds[ii].float() / 2. / gblur
-                sigma0 = diams[iblur] / 30. * gblur * (1 / gblur + (1 - 1 / gblur) * xr[iblur])
-                sigma1 = sigma0.clone()
-            elif not iso:
-                xr = torch.rand(len(lbl), device=device)
-                if len(ii) > 0:
-                    xr[ii] = (ds[ii].float()) / gblur
-                    xr[ii] = xr[ii] + torch.rand(len(ii), device=device) * 0.7 - 0.35
-                    xr[ii] = torch.clip(xr[ii], 0.05, 1.5)
-                sigma0 = diams[iblur] / 30. * gblur * xr[iblur]
-                sigma1 = sigma0.clone() / 10.
-            else:
-                xrand = np.random.exponential(1, size=iblur.sum())
-                xrand = np.clip(xrand * 0.5, 0.1, 1.0)
-                xrand *= gblur
-                sigma0 = diams[iblur] / 30. * 5. * torch.from_numpy(xrand).float().to(
-                    device)
-                sigma1 = sigma0.clone()
-        else:
-            sigma0 = sigma0 * torch.ones((iblur.sum(),), device=device)
-            sigma1 = sigma1 * torch.ones((iblur.sum(),), device=device)
-
-        # create gaussian filter
-        xr = max(8, sigma0.max().long() * 2)
-        gfilt0 = torch.exp(-torch.arange(-xr + 1, xr, device=device)**2 /
-                           (2 * sigma0.unsqueeze(-1)**2))
-        gfilt0 /= gfilt0.sum(axis=-1, keepdims=True)
-        gfilt1 = torch.zeros_like(gfilt0)
-        gfilt1[sigma1 == sigma0] = gfilt0[sigma1 == sigma0]
-        gfilt1[sigma1 != sigma0] = torch.exp(
-            -torch.arange(-xr + 1, xr, device=device)**2 /
-            (2 * sigma1[sigma1 != sigma0].unsqueeze(-1)**2))
-        gfilt1[sigma1 == 0] = 0.
-        gfilt1[sigma1 == 0, xr] = 1.
-        gfilt1 /= gfilt1.sum(axis=-1, keepdims=True)
-        gfilt = torch.einsum("ck,cl->ckl", gfilt0, gfilt1)
-        gfilt /= gfilt.sum(axis=(1, 2), keepdims=True)
-
-        lbl_blur = conv2d(lbl[iblur].transpose(1, 0), gfilt.unsqueeze(1),
-                             padding=gfilt.shape[-1] // 2,
-                             groups=gfilt.shape[0]).transpose(1, 0)
-        if partial_blur:
-            #yc, xc = np.random.randint(100, Ly-100), np.random.randint(100, Lx-100)
-            imgi[iblur] = lbl[iblur].clone()
-            Lxc = int(Lx * 0.85)
-            ym, xm = torch.meshgrid(torch.zeros(Ly, dtype=torch.float32), 
-                                    torch.arange(0, Lxc, dtype=torch.float32), 
-                        indexing="ij")
-            mask = torch.exp(-(ym**2 + xm**2) / 2*(0.001**2))
-            mask -= mask.min()
-            mask /= mask.max()
-            lbl_blur_crop = lbl_blur[:, :, :, :Lxc]
-            imgi[iblur, :, :, :Lxc] = (lbl_blur_crop * mask + 
-                                (1-mask) * imgi[iblur, :, :, :Lxc])
-        else:
-            imgi[iblur] = lbl_blur
-
-    imgi[~iblur] = lbl[~iblur]
-
-    # apply downsample
-    for k in ii:
-        i0 = imgi[k:k + 1, :, ::ds[k], ::ds[k]] if iso else imgi[k:k + 1, :, ::ds[k]]
-        imgi[k] = interpolate(i0, size=lbl[k].shape[-2:], mode="bilinear")
-
-    # add poisson noise
-    ipoisson = np.random.rand(len(lbl)) < poisson
-    if ipoisson.sum() > 0:
-        if pscale is None:
-            pscale = torch.zeros(len(lbl))
-            m = torch.distributions.gamma.Gamma(alpha, beta)
-            pscale = torch.clamp(m.rsample(sample_shape=(ipoisson.sum(),)), 1.)
-            #pscale = torch.clamp(20 * (torch.rand(size=(len(lbl),), device=lbl.device)), 1.5)
-            pscale = pscale.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1).to(device)
-        else:
-            pscale = pscale * torch.ones((ipoisson.sum(), 1, 1, 1), device=device)
-        imgi[ipoisson] = torch.poisson(pscale * imgi[ipoisson])
-    imgi[~ipoisson] = imgi[~ipoisson]
-
-    # renormalize
-    imgi = img_norm(imgi)
-
-    return imgi
-
-
-def random_rotate_and_resize_noise(data, labels=None, diams=None, poisson=0.7, blur=0.7,
-                                   downsample=0.0, beta=0.7, gblur=1.0, diam_mean=30,
-                                   ds_max=7, uniform_blur=False, iso=True, rotate=True,
-                                   device=torch.device("cuda"), xy=(224, 224),
-                                   nchan_noise=1, keep_raw=True):
-    """
-    Applies random rotation, resizing, and noise to the input data.
-
-    Args:
-        data (numpy.ndarray): The input data.
-        labels (numpy.ndarray, optional): The flow and cellprob labels associated with the data. Defaults to None.
-        diams (float, optional): The diameter of the objects. Defaults to None.
-        poisson (float, optional): The Poisson noise probability. Defaults to 0.7.
-        blur (float, optional): The blur probability. Defaults to 0.7.
-        downsample (float, optional): The downsample probability. Defaults to 0.0.
-        beta (float, optional): The beta value for the poisson noise distribution. Defaults to 0.7.
-        gblur (float, optional): The Gaussian blur level. Defaults to 1.0.
-        diam_mean (float, optional): The mean diameter. Defaults to 30.
-        ds_max (int, optional): The maximum downsample value. Defaults to 7.
-        iso (bool, optional): Whether to apply isotropic augmentation. Defaults to True.
-        rotate (bool, optional): Whether to apply rotation augmentation. Defaults to True.
-        device (torch.device, optional): The device to use. Defaults to torch.device("cuda").
-        xy (tuple, optional): The size of the output image. Defaults to (224, 224).
-        nchan_noise (int, optional): The number of channels to add noise to. Defaults to 1.
-        keep_raw (bool, optional): Whether to keep the raw image. Defaults to True.
-
-    Returns:
-        torch.Tensor: The augmented image and augmented noisy/blurry/downsampled version of image.
-        torch.Tensor: The augmented labels.
-        float: The scale factor applied to the image.
-    """
-    if device == None:
-        device = torch.device('cuda') if torch.cuda.is_available() else torch.device('mps') if torch.backends.mps.is_available() else None
-    
-    diams = 30 if diams is None else diams
-    random_diam = diam_mean * (2**(2 * np.random.rand(len(data)) - 1))
-    random_rsc = diams / random_diam  #/ random_diam
-    #rsc /= random_scale
-    xy0 = (340, 340)
-    nchan = data[0].shape[0]
-    data_new = np.zeros((len(data), (1 + keep_raw) * nchan, xy0[0], xy0[1]), "float32")
-    labels_new = np.zeros((len(data), 3, xy0[0], xy0[1]), "float32")
-    for i in range(
-            len(data)):  #, (sc, img, lbl) in enumerate(zip(random_rsc, data, labels)):
-        sc = random_rsc[i]
-        img = data[i]
-        lbl = labels[i] if labels is not None else None
-        # create affine transform to resize
-        Ly, Lx = img.shape[-2:]
-        dxy = np.maximum(0, np.array([Lx / sc - xy0[1], Ly / sc - xy0[0]]))
-        dxy = (np.random.rand(2,) - .5) * dxy
-        cc = np.array([Lx / 2, Ly / 2])
-        cc1 = cc - np.array([Lx - xy0[1], Ly - xy0[0]]) / 2 + dxy
-        pts1 = np.float32([cc, cc + np.array([1, 0]), cc + np.array([0, 1])])
-        pts2 = np.float32(
-            [cc1, cc1 + np.array([1, 0]) / sc, cc1 + np.array([0, 1]) / sc])
-        M = cv2.getAffineTransform(pts1, pts2)
-
-        # apply to image
-        for c in range(nchan):
-            img_rsz = cv2.warpAffine(img[c], M, xy0, flags=cv2.INTER_LINEAR)
-            #img_noise = add_noise(torch.from_numpy(img_rsz).to(device).unsqueeze(0)).cpu().numpy().squeeze(0)
-            data_new[i, c] = img_rsz
-            if keep_raw:
-                data_new[i, c + nchan] = img_rsz
-
-        if lbl is not None:
-            # apply to labels
-            labels_new[i, 0] = cv2.warpAffine(lbl[0], M, xy0, flags=cv2.INTER_NEAREST)
-            labels_new[i, 1] = cv2.warpAffine(lbl[1], M, xy0, flags=cv2.INTER_LINEAR)
-            labels_new[i, 2] = cv2.warpAffine(lbl[2], M, xy0, flags=cv2.INTER_LINEAR)
-
-    rsc = random_diam / diam_mean
-
-    # add noise before augmentations
-    img = torch.from_numpy(data_new).to(device)
-    img = torch.clamp(img, 0.)
-    # just add noise to cyto if nchan_noise=1
-    img[:, :nchan_noise] = add_noise(
-        img[:, :nchan_noise], poisson=poisson, blur=blur, ds_max=ds_max, iso=iso,
-        downsample=downsample, beta=beta, gblur=gblur,
-        diams=torch.from_numpy(random_diam).to(device).float())
-    # img -= img.mean(dim=(-2,-1), keepdim=True)
-    # img /= img.std(dim=(-2,-1), keepdim=True) + 1e-3
-    img = img.cpu().numpy()
-
-    # augmentations
-    img, lbl, scale = transforms.random_rotate_and_resize(
-        img,
-        Y=labels_new,
-        xy=xy,
-        rotate=False if not iso else rotate,
-        #(iso and downsample==0),
-        rescale=rsc,
-        scale_range=0.5)
-    img = torch.from_numpy(img).to(device)
-    lbl = torch.from_numpy(lbl).to(device)
-
-    return img, lbl, scale
-
-
-def one_chan_cellpose(device, model_type="cyto2", pretrained_model=None):
-    """
-    Creates a Cellpose network with a single input channel.
-
-    Args:
-        device (str): The device to run the network on.
-        model_type (str, optional): The type of Cellpose model to use. Defaults to "cyto2".
-        pretrained_model (str, optional): The path to a pretrained model file. Defaults to None.
-
-    Returns:
-        torch.nn.Module: The Cellpose network with a single input channel.
-    """
-    if pretrained_model is not None and not os.path.exists(pretrained_model):
-        model_type = pretrained_model
-        pretrained_model = None
-    nbase = [32, 64, 128, 256]
-    nchan = 1
-    net1 = resnet_torch.CPnet([nchan, *nbase], nout=3, sz=3).to(device)
-    filename = model_path(model_type,
-                          0) if pretrained_model is None else pretrained_model
-    weights = torch.load(filename, weights_only=True)
-    zp = 0
-    print(filename)
-    for name in net1.state_dict():
-        if ("res_down_0.conv.conv_0" not in name and
-                #"output" not in name and
-                "res_down_0.proj" not in name and name != "diam_mean" and
-                name != "diam_labels"):
-            net1.state_dict()[name].copy_(weights[name])
-        elif "res_down_0" in name:
-            if len(weights[name].shape) > 0:
-                new_weight = torch.zeros_like(net1.state_dict()[name])
-                if weights[name].shape[0] == 2:
-                    new_weight[:] = weights[name][0]
-                elif len(weights[name].shape) > 1 and weights[name].shape[1] == 2:
-                    new_weight[:, zp] = weights[name][:, 0]
-                else:
-                    new_weight = weights[name]
-            else:
-                new_weight = weights[name]
-            net1.state_dict()[name].copy_(new_weight)
-    return net1
-
-
-class CellposeDenoiseModel():
-    """ model to run Cellpose and Image restoration """
-
-    def __init__(self, gpu=False, pretrained_model=False, model_type=None,
-                 restore_type="denoise_cyto3", nchan=2,
-                 chan2_restore=False, device=None):
-
-        self.dn = DenoiseModel(gpu=gpu, model_type=restore_type, chan2=chan2_restore,
-                               device=device)
-        self.cp = CellposeModel(gpu=gpu, model_type=model_type, nchan=nchan,
-                                pretrained_model=pretrained_model, device=device)
-
-    def eval(self, x, batch_size=8, channels=None, channel_axis=None, z_axis=None,
-             normalize=True, rescale=None, diameter=None, tile_overlap=0.1,
-             augment=False, resample=True, invert=False, flow_threshold=0.4,
-             cellprob_threshold=0.0, do_3D=False, anisotropy=None, stitch_threshold=0.0,
-             min_size=15, niter=None, interp=True, bsize=224, flow3D_smooth=0):
-        """
-        Restore array or list of images using the image restoration model, and then segment.
-
-        Args:
-            x (list, np.ndarry): can be list of 2D/3D/4D images, or array of 2D/3D/4D images
-            batch_size (int, optional): number of 224x224 patches to run simultaneously on the GPU
-                (can make smaller or bigger depending on GPU memory usage). Defaults to 8.
-            channels (list, optional): list of channels, either of length 2 or of length number of images by 2.
-                First element of list is the channel to segment (0=grayscale, 1=red, 2=green, 3=blue).
-                Second element of list is the optional nuclear channel (0=none, 1=red, 2=green, 3=blue).
-                For instance, to segment grayscale images, input [0,0]. To segment images with cells
-                in green and nuclei in blue, input [2,3]. To segment one grayscale image and one
-                image with cells in green and nuclei in blue, input [[0,0], [2,3]].
-                Defaults to None.
-            channel_axis (int, optional): channel axis in element of list x, or of np.ndarray x. 
-                if None, channels dimension is attempted to be automatically determined. Defaults to None.
-            z_axis  (int, optional): z axis in element of list x, or of np.ndarray x. 
-                if None, z dimension is attempted to be automatically determined. Defaults to None.
-            normalize (bool, optional): if True, normalize data so 0.0=1st percentile and 1.0=99th percentile of image intensities in each channel; 
-                can also pass dictionary of parameters (all keys are optional, default values shown): 
-                    - "lowhigh"=None : pass in normalization values for 0.0 and 1.0 as list [low, high] (if not None, all following parameters ignored)
-                    - "sharpen"=0 ; sharpen image with high pass filter, recommended to be 1/4-1/8 diameter of cells in pixels
-                    - "normalize"=True ; run normalization (if False, all following parameters ignored)
-                    - "percentile"=None : pass in percentiles to use as list [perc_low, perc_high]
-                    - "tile_norm"=0 ; compute normalization in tiles across image to brighten dark areas, to turn on set to window size in pixels (e.g. 100)
-                    - "norm3D"=False ; compute normalization across entire z-stack rather than plane-by-plane in stitching mode.
-                Defaults to True.
-            rescale (float, optional): resize factor for each image, if None, set to 1.0;
-                (only used if diameter is None). Defaults to None.
-            diameter (float, optional):  diameter for each image, 
-                if diameter is None, set to diam_mean or diam_train if available. Defaults to None.
-            tile_overlap (float, optional): fraction of overlap of tiles when computing flows. Defaults to 0.1.
-            augment (bool, optional): augment tiles by flipping and averaging for segmentation. Defaults to False.
-            resample (bool, optional): run dynamics at original image size (will be slower but create more accurate boundaries). Defaults to True.
-            invert (bool, optional): invert image pixel intensity before running network. Defaults to False.
-            flow_threshold (float, optional): flow error threshold (all cells with errors below threshold are kept) (not used for 3D). Defaults to 0.4.
-            cellprob_threshold (float, optional): all pixels with value above threshold kept for masks, decrease to find more and larger masks. Defaults to 0.0.
-            do_3D (bool, optional): set to True to run 3D segmentation on 3D/4D image input. Defaults to False.
-            anisotropy (float, optional): for 3D segmentation, optional rescaling factor (e.g. set to 2.0 if Z is sampled half as dense as X or Y). Defaults to None.
-            stitch_threshold (float, optional): if stitch_threshold>0.0 and not do_3D, masks are stitched in 3D to return volume segmentation. Defaults to 0.0.
-            min_size (int, optional): all ROIs below this size, in pixels, will be discarded. Defaults to 15.
-            flow3D_smooth (int, optional): if do_3D and flow3D_smooth>0, smooth flows with gaussian filter of this stddev. Defaults to 0.
-            niter (int, optional): number of iterations for dynamics computation. if None, it is set proportional to the diameter. Defaults to None.
-            interp (bool, optional): interpolate during 2D dynamics (not available in 3D) . Defaults to True.
-            
-        Returns:
-            A tuple containing (masks, flows, styles, imgs); masks: labelled image(s), where 0=no masks; 1,2,...=mask labels; 
-            flows: list of lists: flows[k][0] = XY flow in HSV 0-255; flows[k][1] = XY(Z) flows at each pixel; flows[k][2] = cell probability (if > cellprob_threshold, pixel used for dynamics); flows[k][3] = final pixel locations after Euler integration;
-            styles: style vector summarizing each image of size 256;
-            imgs: Restored images.
-        """
-        
-        if isinstance(normalize, dict):
-            normalize_params = {**normalize_default, **normalize}
-        elif not isinstance(normalize, bool):
-            raise ValueError("normalize parameter must be a bool or a dict")
-        else:
-            normalize_params = normalize_default
-            normalize_params["normalize"] = normalize
-        normalize_params["invert"] = invert
-
-        img_restore = self.dn.eval(x, batch_size=batch_size, channels=channels,
-                                   channel_axis=channel_axis, z_axis=z_axis,
-                                   do_3D=do_3D, 
-                                   normalize=normalize_params, rescale=rescale,
-                                   diameter=diameter,
-                                   tile_overlap=tile_overlap, bsize=bsize)
-
-        # turn off special normalization for segmentation
-        normalize_params = normalize_default
-
-        # change channels for segmentation
-        if channels is not None:
-            channels_new = [0, 0] if channels[0] == 0 else [1, 2]
-        else:
-            channels_new = None
-        # change diameter if self.ratio > 1 (upsampled to self.dn.diam_mean)
-        diameter = self.dn.diam_mean if self.dn.ratio > 1 else diameter
-        masks, flows, styles = self.cp.eval(
-            img_restore, batch_size=batch_size, channels=channels_new, channel_axis=-1,
-            z_axis=0 if not isinstance(img_restore, list) and img_restore.ndim > 3 and img_restore.shape[0] > 0 else None,
-            normalize=normalize_params, rescale=rescale, diameter=diameter,
-            tile_overlap=tile_overlap, augment=augment, resample=resample,
-            invert=invert, flow_threshold=flow_threshold,
-            cellprob_threshold=cellprob_threshold, do_3D=do_3D, anisotropy=anisotropy,
-            stitch_threshold=stitch_threshold, min_size=min_size, niter=niter,
-            interp=interp, bsize=bsize)
-
-        return masks, flows, styles, img_restore
-
-
-class DenoiseModel():
-    """
-    DenoiseModel class for denoising images using Cellpose denoising model.
-
-    Args:
-        gpu (bool, optional): Whether to use GPU for computation. Defaults to False.
-        pretrained_model (bool or str or Path, optional): Pretrained model to use for denoising.
-            Can be a string or path. Defaults to False.
-        nchan (int, optional): Number of channels in the input images, all Cellpose 3 models were trained with nchan=1. Defaults to 1.
-        model_type (str, optional): Type of pretrained model to use ("denoise_cyto3", "deblur_cyto3", "upsample_cyto3", ...). Defaults to None.
-        chan2 (bool, optional): Whether to use a separate model for the second channel. Defaults to False.
-        diam_mean (float, optional): Mean diameter of the objects in the images. Defaults to 30.0.
-        device (torch.device, optional): Device to use for computation. Defaults to None.
-
-    Attributes:
-        nchan (int): Number of channels in the input images.
-        diam_mean (float): Mean diameter of the objects in the images.
-        net (CPnet): Cellpose network for denoising.
-        pretrained_model (bool or str or Path): Pretrained model path to use for denoising.
-        net_chan2 (CPnet or None): Cellpose network for the second channel, if applicable.
-        net_type (str): Type of the denoising network.
-
-    Methods:
-        eval(x, batch_size=8, channels=None, channel_axis=None, z_axis=None,
-                normalize=True, rescale=None, diameter=None, tile=True, tile_overlap=0.1)
-            Denoise array or list of images using the denoising model.
-
-        _eval(net, x, normalize=True, rescale=None, diameter=None, tile=True,
-                tile_overlap=0.1)
-            Run denoising model on a single channel.
-    """
-
-    def __init__(self, gpu=False, pretrained_model=False, nchan=1, model_type=None,
-                 chan2=False, diam_mean=30., device=None):
-        self.nchan = nchan
-        if pretrained_model and (not isinstance(pretrained_model, str) and
-                                 not isinstance(pretrained_model, Path)):
-            raise ValueError("pretrained_model must be a string or path")
-
-        self.diam_mean = diam_mean
-        builtin = True
-        if model_type is not None or (pretrained_model and
-                                      not os.path.exists(pretrained_model)):
-            pretrained_model_string = model_type if model_type is not None else "denoise_cyto3"
-            if ~np.any([pretrained_model_string == s for s in MODEL_NAMES]):
-                pretrained_model_string = "denoise_cyto3"
-            pretrained_model = model_path(pretrained_model_string)
-            if (pretrained_model and not os.path.exists(pretrained_model)):
-                denoise_logger.warning("pretrained model has incorrect path")
-            denoise_logger.info(f">> {pretrained_model_string} << model set to be used")
-            self.diam_mean = 17. if "nuclei" in pretrained_model_string else 30.
-        else:
-            if pretrained_model:
-                builtin = False
-                pretrained_model_string = pretrained_model
-                denoise_logger.info(f">>>> loading model {pretrained_model_string}")
-
-        # assign network device
-        if device is None:
-            sdevice, gpu = assign_device(use_torch=True, gpu=gpu)
-        self.device = device if device is not None else sdevice
-        if device is not None:
-            device_gpu = self.device.type == "cuda"
-        self.gpu = gpu if device is None else device_gpu
-        
-        # create network
-        self.nchan = nchan
-        self.nclasses = 1
-        nbase = [32, 64, 128, 256]
-        self.nchan = nchan
-        self.nbase = [nchan, *nbase]
-
-        self.net = CPnet(self.nbase, self.nclasses, sz=3, 
-                         max_pool=True, diam_mean=diam_mean).to(self.device)
-
-        self.pretrained_model = pretrained_model
-        self.net_chan2 = None
-        if self.pretrained_model:
-            self.net.load_model(self.pretrained_model, device=self.device)
-            denoise_logger.info(
-                f">>>> model diam_mean = {self.diam_mean: .3f} (ROIs rescaled to this size during training)"
-            )
-            if chan2 and builtin:
-                chan2_path = model_path(
-                    os.path.split(self.pretrained_model)[-1].split("_")[0] + "_nuclei")
-                print(f"loading model for chan2: {os.path.split(str(chan2_path))[-1]}")
-                self.net_chan2 = CPnet(self.nbase, self.nclasses, sz=3,
-                                        max_pool=True,
-                                       diam_mean=17.).to(self.device)
-                self.net_chan2.load_model(chan2_path, device=self.device)
-        self.net_type = "cellpose_denoise"
-
-    def eval(self, x, batch_size=8, channels=None, channel_axis=None, z_axis=None,
-             normalize=True, rescale=None, diameter=None, tile=True, do_3D=False,
-             tile_overlap=0.1, bsize=224):
-        """
-        Restore array or list of images using the image restoration model.
-
-        Args:
-            x (list, np.ndarry): can be list of 2D/3D/4D images, or array of 2D/3D/4D images
-            batch_size (int, optional): number of 224x224 patches to run simultaneously on the GPU
-                (can make smaller or bigger depending on GPU memory usage). Defaults to 8.
-            channels (list, optional): list of channels, either of length 2 or of length number of images by 2.
-                First element of list is the channel to segment (0=grayscale, 1=red, 2=green, 3=blue).
-                Second element of list is the optional nuclear channel (0=none, 1=red, 2=green, 3=blue).
-                For instance, to segment grayscale images, input [0,0]. To segment images with cells
-                in green and nuclei in blue, input [2,3]. To segment one grayscale image and one
-                image with cells in green and nuclei in blue, input [[0,0], [2,3]].
-                Defaults to None.
-            channel_axis (int, optional): channel axis in element of list x, or of np.ndarray x. 
-                if None, channels dimension is attempted to be automatically determined. Defaults to None.
-            z_axis  (int, optional): z axis in element of list x, or of np.ndarray x. 
-                if None, z dimension is attempted to be automatically determined. Defaults to None.
-            normalize (bool, optional): if True, normalize data so 0.0=1st percentile and 1.0=99th percentile of image intensities in each channel; 
-                can also pass dictionary of parameters (all keys are optional, default values shown): 
-                    - "lowhigh"=None : pass in normalization values for 0.0 and 1.0 as list [low, high] (if not None, all following parameters ignored)
-                    - "sharpen"=0 ; sharpen image with high pass filter, recommended to be 1/4-1/8 diameter of cells in pixels
-                    - "normalize"=True ; run normalization (if False, all following parameters ignored)
-                    - "percentile"=None : pass in percentiles to use as list [perc_low, perc_high]
-                    - "tile_norm"=0 ; compute normalization in tiles across image to brighten dark areas, to turn on set to window size in pixels (e.g. 100)
-                    - "norm3D"=False ; compute normalization across entire z-stack rather than plane-by-plane in stitching mode.
-                Defaults to True.
-            rescale (float, optional): resize factor for each image, if None, set to 1.0;
-                (only used if diameter is None). Defaults to None.
-            diameter (float, optional):  diameter for each image, 
-                if diameter is None, set to diam_mean or diam_train if available. Defaults to None.
-            tile_overlap (float, optional): fraction of overlap of tiles when computing flows. Defaults to 0.1.
-              
-        Returns:
-            list: A list of 2D/3D arrays of restored images
-
-        """
-        if isinstance(x, list) or x.squeeze().ndim == 5:
-            tqdm_out = utils.TqdmToLogger(denoise_logger, level=logging.INFO)
-            nimg = len(x)
-            iterator = trange(nimg, file=tqdm_out,
-                              mininterval=30) if nimg > 1 else range(nimg)
-            imgs = []
-            for i in iterator:
-                imgi = self.eval(
-                    x[i], batch_size=batch_size,
-                    channels=channels[i] if channels is not None and
-                    ((len(channels) == len(x) and
-                      (isinstance(channels[i], list) or
-                       isinstance(channels[i], np.ndarray)) and len(channels[i]) == 2))
-                    else channels, channel_axis=channel_axis, z_axis=z_axis,
-                    normalize=normalize,
-                    do_3D=do_3D,
-                    rescale=rescale[i] if isinstance(rescale, list) or
-                    isinstance(rescale, np.ndarray) else rescale,
-                    diameter=diameter[i] if isinstance(diameter, list) or
-                    isinstance(diameter, np.ndarray) else diameter, 
-                    tile_overlap=tile_overlap, bsize=bsize)
-                imgs.append(imgi)
-            if isinstance(x, np.ndarray):
-                imgs = np.array(imgs)
-            return imgs
-
-        else:
-            # reshape image
-            x = transforms.convert_image(x, channels, channel_axis=channel_axis,
-                                         z_axis=z_axis, do_3D=do_3D, nchan=None)
-            if x.ndim < 4:
-                squeeze = True
-                x = x[np.newaxis, ...]
-            else:
-                squeeze = False
-
-            # may need to interpolate image before running upsampling
-            self.ratio = 1.
-            if "upsample" in self.pretrained_model:
-                Ly, Lx = x.shape[-3:-1]
-                if diameter is not None and 3 <= diameter < self.diam_mean:
-                    self.ratio = self.diam_mean / diameter
-                    denoise_logger.info(
-                        f"upsampling image to {self.diam_mean} pixel diameter ({self.ratio:0.2f} times)"
-                    )
-                    Lyr, Lxr = int(Ly * self.ratio), int(Lx * self.ratio)
-                    x = transforms.resize_image(x, Ly=Lyr, Lx=Lxr)
-                else:
-                    denoise_logger.warning(
-                        f"not interpolating image before upsampling because diameter is set >= {self.diam_mean}"
-                    )
-                    #raise ValueError(f"diameter is set to {diameter}, needs to be >=3 and < {self.dn.diam_mean}")
-
-            self.batch_size = batch_size
-
-            if diameter is not None and diameter > 0:
-                rescale = self.diam_mean / diameter
-            elif rescale is None:
-                rescale = 1.0
-
-            if np.ptp(x[..., -1]) < 1e-3 or (channels is not None and channels[-1] == 0):
-                x = x[..., :1]
-
-            for c in range(x.shape[-1]):
-                rescale0 = rescale * 30. / 17. if c == 1 else rescale
-                if c == 0 or self.net_chan2 is None:
-                    x[...,
-                      c] = self._eval(self.net, x[..., c:c + 1], batch_size=batch_size,
-                                      normalize=normalize, rescale=rescale0, 
-                                      tile_overlap=tile_overlap, bsize=bsize)[...,0]
-                else:
-                    x[...,
-                      c] = self._eval(self.net_chan2, x[...,
-                                                        c:c + 1], batch_size=batch_size,
-                                      normalize=normalize, rescale=rescale0, 
-                                      tile_overlap=tile_overlap, bsize=bsize)[...,0]
-            x = x[0] if squeeze else x
-        return x
-
-    def _eval(self, net, x, batch_size=8, normalize=True, rescale=None,
-              tile_overlap=0.1, bsize=224):
-        """
-        Run image restoration model on a single channel.
-
-        Args:
-            x (list, np.ndarry): can be list of 2D/3D/4D images, or array of 2D/3D/4D images
-            batch_size (int, optional): number of 224x224 patches to run simultaneously on the GPU
-                (can make smaller or bigger depending on GPU memory usage). Defaults to 8.
-            normalize (bool, optional): if True, normalize data so 0.0=1st percentile and 1.0=99th percentile of image intensities in each channel; 
-                can also pass dictionary of parameters (all keys are optional, default values shown): 
-                    - "lowhigh"=None : pass in normalization values for 0.0 and 1.0 as list [low, high] (if not None, all following parameters ignored)
-                    - "sharpen"=0 ; sharpen image with high pass filter, recommended to be 1/4-1/8 diameter of cells in pixels
-                    - "normalize"=True ; run normalization (if False, all following parameters ignored)
-                    - "percentile"=None : pass in percentiles to use as list [perc_low, perc_high]
-                    - "tile_norm"=0 ; compute normalization in tiles across image to brighten dark areas, to turn on set to window size in pixels (e.g. 100)
-                    - "norm3D"=False ; compute normalization across entire z-stack rather than plane-by-plane in stitching mode.
-                Defaults to True.
-            rescale (float, optional): resize factor for each image, if None, set to 1.0;
-                (only used if diameter is None). Defaults to None.
-            tile_overlap (float, optional): fraction of overlap of tiles when computing flows. Defaults to 0.1.
-            
-        Returns:
-            list: A list of 2D/3D arrays of restored images
-
-        """
-        if isinstance(normalize, dict):
-            normalize_params = {**normalize_default, **normalize}
-        elif not isinstance(normalize, bool):
-            raise ValueError("normalize parameter must be a bool or a dict")
-        else:
-            normalize_params = normalize_default
-            normalize_params["normalize"] = normalize
-
-        tic = time.time()
-        shape = x.shape
-        nimg = shape[0]
-
-        do_normalization = True if normalize_params["normalize"] else False
-
-        img = np.asarray(x)
-        if do_normalization:
-            img = transforms.normalize_img(img, **normalize_params)
-        if rescale != 1.0:
-            img = transforms.resize_image(img, rsz=rescale)
-        yf, style = run_net(self.net, img, bsize=bsize,
-                            tile_overlap=tile_overlap)
-        yf = transforms.resize_image(yf, shape[1], shape[2])
-        imgs = yf
-        del yf, style
-
-        # imgs = np.zeros((*x.shape[:-1], 1), np.float32)
-        # for i in iterator:
-        #     img = np.asarray(x[i])
-        #     if do_normalization:
-        #         img = transforms.normalize_img(img, **normalize_params)
-        #     if rescale != 1.0:
-        #         img = transforms.resize_image(img, rsz=[rescale, rescale])
-        #         if img.ndim == 2:
-        #             img = img[:, :, np.newaxis]
-        #     yf, style = run_net(net, img, batch_size=batch_size, augment=False,
-        #                         tile=tile, tile_overlap=tile_overlap, bsize=bsize)
-        #     img = transforms.resize_image(yf, Ly=x.shape[-3], Lx=x.shape[-2])
-
-        #     if img.ndim == 2:
-        #         img = img[:, :, np.newaxis]
-        #     imgs[i] = img
-        #     del yf, style
-        net_time = time.time() - tic
-        if nimg > 1:
-            denoise_logger.info("imgs denoised in %2.2fs" % (net_time))
-
-        return imgs
-
-
-def train(net, train_data=None, train_labels=None, train_files=None, test_data=None,
-          test_labels=None, test_files=None, train_probs=None, test_probs=None,
-          lam=[1., 1.5, 0.], scale_range=0.5, seg_model_type="cyto2", save_path=None,
-          save_every=100, save_each=False, poisson=0.7, beta=0.7, blur=0.7, gblur=1.0,
-          iso=True, uniform_blur=False, downsample=0., ds_max=7,
-          learning_rate=0.005, n_epochs=500,
-          weight_decay=0.00001, batch_size=8, nimg_per_epoch=None,
-          nimg_test_per_epoch=None, model_name=None):
-
-    # net properties
-    device = net.device
-    nchan = net.nchan
-    diam_mean = net.diam_mean.item()
-
-    args = np.array([poisson, beta, blur, gblur, downsample])
-    if args.ndim == 1:
-        args = args[:, np.newaxis]
-    poisson, beta, blur, gblur, downsample = args
-    nnoise = len(poisson)
-
-    d = datetime.datetime.now()
-    if save_path is not None:
-        if model_name is None:  
-            filename = ""
-            lstrs = ["per", "seg", "rec"]
-            for k, (l, s) in enumerate(zip(lam, lstrs)):
-                filename += f"{s}_{l:.2f}_"
-            if not iso:
-                filename += "aniso_"
-            if poisson.sum() > 0:
-                filename += "poisson_"
-            if blur.sum() > 0:
-                filename += "blur_"
-            if downsample.sum() > 0:
-                filename += "downsample_"
-            filename += d.strftime("%Y_%m_%d_%H_%M_%S.%f")
-            filename = os.path.join(save_path, filename)
-        else:
-            filename = os.path.join(save_path, model_name)
-        print(filename)
-    for i in range(len(poisson)):
-        denoise_logger.info(
-            f"poisson: {poisson[i]: 0.2f}, beta: {beta[i]: 0.2f}, blur: {blur[i]: 0.2f}, gblur: {gblur[i]: 0.2f}, downsample: {downsample[i]: 0.2f}"
-        )
-    net1 = one_chan_cellpose(device=device, pretrained_model=seg_model_type)
-
-    learning_rate_const = learning_rate
-    LR = np.linspace(0, learning_rate_const, 10)
-    LR = np.append(LR, learning_rate_const * np.ones(n_epochs - 100))
-    for i in range(10):
-        LR = np.append(LR, LR[-1] / 2 * np.ones(10))
-    learning_rate = LR
-
-    batch_size = 8
-    optimizer = torch.optim.AdamW(net.parameters(), lr=learning_rate[0],
-                                  weight_decay=weight_decay)
-    if train_data is not None:
-        nimg = len(train_data)
-        diam_train = np.array(
-            [utils.diameters(train_labels[k])[0] for k in trange(len(train_labels))])
-        diam_train[diam_train < 5] = 5.
-        if test_data is not None:
-            diam_test = np.array(
-                [utils.diameters(test_labels[k])[0] for k in trange(len(test_labels))])
-            diam_test[diam_test < 5] = 5.
-            nimg_test = len(test_data)
-    else:
-        nimg = len(train_files)
-        denoise_logger.info(">>> using files instead of loading dataset")
-        train_labels_files = [str(tf)[:-4] + f"_flows.tif" for tf in train_files]
-        denoise_logger.info(">>> computing diameters")
-        diam_train = np.array([
-            utils.diameters(io.imread(train_labels_files[k])[0])[0]
-            for k in trange(len(train_labels_files))
-        ])
-        diam_train[diam_train < 5] = 5.
-        if test_files is not None:
-            nimg_test = len(test_files)
-            test_labels_files = [str(tf)[:-4] + f"_flows.tif" for tf in test_files]
-            diam_test = np.array([
-                utils.diameters(io.imread(test_labels_files[k])[0])[0]
-                for k in trange(len(test_labels_files))
-            ])
-            diam_test[diam_test < 5] = 5.
-    train_probs = 1. / nimg * np.ones(nimg,
-                                      "float64") if train_probs is None else train_probs
-    if test_files is not None or test_data is not None:
-        test_probs = 1. / nimg_test * np.ones(
-            nimg_test, "float64") if test_probs is None else test_probs
-
-    tic = time.time()
-
-    nimg_per_epoch = nimg if nimg_per_epoch is None else nimg_per_epoch
-    if test_files is not None or test_data is not None:
-        nimg_test_per_epoch = nimg_test if nimg_test_per_epoch is None else nimg_test_per_epoch
-
-    nbatch = 0
-    train_losses, test_losses = [], []
-    for iepoch in range(n_epochs):
-        np.random.seed(iepoch)
-        rperm = np.random.choice(np.arange(0, nimg), size=(nimg_per_epoch,),
-                                 p=train_probs)
-        torch.manual_seed(iepoch)
-        np.random.seed(iepoch)
-        for param_group in optimizer.param_groups:
-            param_group["lr"] = learning_rate[iepoch]
-        lavg, lavg_per, nsum = 0, 0, 0
-        for ibatch in range(0, nimg_per_epoch, batch_size * nnoise):
-            inds = rperm[ibatch : ibatch + batch_size * nnoise]
-            if train_data is None:
-                imgs = [np.maximum(0, io.imread(train_files[i])[:nchan]) for i in inds]
-                lbls = [io.imread(train_labels_files[i])[1:] for i in inds]
-            else:
-                imgs = [train_data[i][:nchan] for i in inds]
-                lbls = [train_labels[i][1:] for i in inds]
-            #inoise = nbatch % nnoise
-            rnoise = np.random.permutation(nnoise)
-            for i, inoise in enumerate(rnoise):
-                if i * batch_size < len(imgs):
-                    imgi, lbli, scale = random_rotate_and_resize_noise(
-                        imgs[i * batch_size : (i + 1) * batch_size], 
-                        lbls[i * batch_size : (i + 1) * batch_size],
-                        diam_train[inds][i * batch_size : (i + 1) * batch_size].copy(), 
-                        poisson=poisson[inoise],
-                        beta=beta[inoise], gblur=gblur[inoise], blur=blur[inoise], iso=iso,
-                        downsample=downsample[inoise], uniform_blur=uniform_blur,
-                        diam_mean=diam_mean, ds_max=ds_max,
-                        device=device)
-                    if i == 0:
-                        img = imgi 
-                        lbl = lbli 
-                    else:
-                        img = torch.cat((img, imgi), axis=0)
-                        lbl = torch.cat((lbl, lbli), axis=0)
-
-            if nnoise > 0:
-                iperm = np.random.permutation(img.shape[0])
-                img, lbl = img[iperm], lbl[iperm]
-            
-            for i in range(nnoise):
-                optimizer.zero_grad()
-                imgi = img[i * batch_size: (i + 1) * batch_size]
-                lbli = lbl[i * batch_size: (i + 1) * batch_size]
-                if imgi.shape[0] > 0:
-                    loss, loss_per = train_loss(net, imgi[:, :nchan], net1=net1,
-                                            img=imgi[:, nchan:], lbl=lbli, lam=lam)
-                    loss.backward()
-                    optimizer.step()
-                    lavg += loss.item() * imgi.shape[0]
-                    lavg_per += loss_per.item() * imgi.shape[0]
-
-            nsum += len(img)
-            nbatch += 1
-
-        if iepoch % 5 == 0 or iepoch < 10:
-            lavg = lavg / nsum
-            lavg_per = lavg_per / nsum
-            if test_data is not None or test_files is not None:
-                lavgt, nsum = 0., 0
-                np.random.seed(42)
-                rperm = np.random.choice(np.arange(0, nimg_test),
-                                         size=(nimg_test_per_epoch,), p=test_probs)
-                inoise = iepoch % nnoise
-                torch.manual_seed(inoise)
-                for ibatch in range(0, nimg_test_per_epoch, batch_size):
-                    inds = rperm[ibatch:ibatch + batch_size]
-                    if test_data is None:
-                        imgs = [
-                            np.maximum(0,
-                                       io.imread(test_files[i])[:nchan]) for i in inds
-                        ]
-                        lbls = [io.imread(test_labels_files[i])[1:] for i in inds]
-                    else:
-                        imgs = [test_data[i][:nchan] for i in inds]
-                        lbls = [test_labels[i][1:] for i in inds]
-                    img, lbl, scale = random_rotate_and_resize_noise(
-                        imgs, lbls, diam_test[inds].copy(), poisson=poisson[inoise],
-                        beta=beta[inoise], blur=blur[inoise], gblur=gblur[inoise],
-                        iso=iso, downsample=downsample[inoise], uniform_blur=uniform_blur,
-                        diam_mean=diam_mean, ds_max=ds_max, device=device)
-                    loss, loss_per = test_loss(net, img[:, :nchan], net1=net1,
-                                               img=img[:, nchan:], lbl=lbl, lam=lam)
-
-                    lavgt += loss.item() * img.shape[0]
-                    nsum += len(img)
-                lavgt = lavgt / nsum
-                denoise_logger.info(
-                    "Epoch %d, Time %4.1fs, Loss %0.3f, loss_per %0.3f, Loss Test %0.3f, LR %2.4f"
-                    % (iepoch, time.time() - tic, lavg, lavg_per, lavgt,
-                       learning_rate[iepoch]))
-                test_losses.append(lavgt)
-            else:
-                denoise_logger.info(
-                    "Epoch %d, Time %4.1fs, Loss %0.3f, loss_per %0.3f, LR %2.4f" %
-                    (iepoch, time.time() - tic, lavg, lavg_per, learning_rate[iepoch]))
-            train_losses.append(lavg)
-            
-        if save_path is not None:
-            if iepoch == n_epochs - 1 or (iepoch % save_every == 0 and iepoch != 0):
-                if save_each:  #separate files as model progresses
-                    filename0 = str(filename) + f"_epoch_{iepoch:%04d}"
-                else:
-                    filename0 = filename
-                denoise_logger.info(f"saving network parameters to {filename0}")
-                net.save_model(filename0)
-        else:
-            filename = save_path
-
-    return filename, train_losses, test_losses
-
-
-if __name__ == "__main__":
-    import argparse
-    parser = argparse.ArgumentParser(description="cellpose parameters")
-
-    input_img_args = parser.add_argument_group("input image arguments")
-    input_img_args.add_argument("--dir", default=[], type=str,
-                                help="folder containing data to run or train on.")
-    input_img_args.add_argument("--img_filter", default=[], type=str,
-                                help="end string for images to run on")
-
-    model_args = parser.add_argument_group("model arguments")
-    model_args.add_argument("--pretrained_model", default=[], type=str,
-                            help="pretrained denoising model")
-
-    training_args = parser.add_argument_group("training arguments")
-    training_args.add_argument("--test_dir", default=[], type=str,
-                               help="folder containing test data (optional)")
-    training_args.add_argument("--file_list", default=[], type=str,
-                               help="npy file containing list of train and test files")
-    training_args.add_argument("--seg_model_type", default="cyto2", type=str,
-                               help="model to use for seg training loss")
-    training_args.add_argument(
-        "--noise_type", default=[], type=str,
-        help="noise type to use (if input, then other noise params are ignored)")
-    training_args.add_argument("--poisson", default=0.8, type=float,
-                               help="fraction of images to add poisson noise to")
-    training_args.add_argument("--beta", default=0.7, type=float,
-                               help="scale of poisson noise")
-    training_args.add_argument("--blur", default=0., type=float,
-                               help="fraction of images to blur")
-    training_args.add_argument("--gblur", default=1.0, type=float,
-                               help="scale of gaussian blurring stddev")
-    training_args.add_argument("--downsample", default=0., type=float,
-                               help="fraction of images to downsample")
-    training_args.add_argument("--ds_max", default=7, type=int,
-                               help="max downsampling factor")
-    training_args.add_argument("--lam_per", default=1.0, type=float,
-                               help="weighting of perceptual loss")
-    training_args.add_argument("--lam_seg", default=1.5, type=float,
-                               help="weighting of segmentation loss")
-    training_args.add_argument("--lam_rec", default=0., type=float,
-                               help="weighting of reconstruction loss")
-    training_args.add_argument(
-        "--diam_mean", default=30., type=float, help=
-        "mean diameter to resize cells to during training -- if starting from pretrained models it cannot be changed from 30.0"
-    )
-    training_args.add_argument("--learning_rate", default=0.001, type=float,
-                               help="learning rate. Default: %(default)s")
-    training_args.add_argument("--n_epochs", default=2000, type=int,
-                               help="number of epochs. Default: %(default)s")
-    training_args.add_argument(
-        "--save_each", default=False, action="store_true",
-        help="save each epoch as separate model")
-    training_args.add_argument(
-        "--nimg_per_epoch", default=0, type=int,
-        help="number of images per epoch. Default is length of training images")
-    training_args.add_argument(
-        "--nimg_test_per_epoch", default=0, type=int,
-        help="number of test images per epoch. Default is length of testing images")
-
-    io.logger_setup()
-
-    args = parser.parse_args()
-    lams = [args.lam_per, args.lam_seg, args.lam_rec]
-    print("lam", lams)
-
-    if len(args.noise_type) > 0:
-        noise_type = args.noise_type
-        uniform_blur = False
-        iso = True
-        if noise_type == "poisson":
-            poisson = 0.8
-            blur = 0.
-            downsample = 0.
-            beta = 0.7
-            gblur = 1.0
-        elif noise_type == "blur_expr":
-            poisson = 0.8
-            blur = 0.8
-            downsample = 0.
-            beta = 0.1
-            gblur = 0.5
-        elif noise_type == "blur":
-            poisson = 0.8
-            blur = 0.8
-            downsample = 0.
-            beta = 0.1
-            gblur = 10.0
-            uniform_blur = True
-        elif noise_type == "downsample_expr":
-            poisson = 0.8
-            blur = 0.8
-            downsample = 0.8
-            beta = 0.03
-            gblur = 1.0
-        elif noise_type == "downsample":
-            poisson = 0.8
-            blur = 0.8
-            downsample = 0.8
-            beta = 0.03
-            gblur = 5.0
-            uniform_blur = True
-        elif noise_type == "all":
-            poisson = [0.8, 0.8, 0.8]
-            blur = [0., 0.8, 0.8]
-            downsample = [0., 0., 0.8]
-            beta = [0.7, 0.1, 0.03]
-            gblur = [0., 10.0, 5.0]
-            uniform_blur = True
-        elif noise_type == "aniso":
-            poisson = 0.8
-            blur = 0.8
-            downsample = 0.8
-            beta = 0.1
-            gblur = args.ds_max * 1.5
-            iso = False
-        else:
-            raise ValueError(f"{noise_type} noise_type is not supported")
-    else:
-        poisson, beta = args.poisson, args.beta
-        blur, gblur = args.blur, args.gblur
-        downsample = args.downsample
-
-    pretrained_model = None if len(
-        args.pretrained_model) == 0 else args.pretrained_model
-    model = DenoiseModel(gpu=True, nchan=1, diam_mean=args.diam_mean,
-                         pretrained_model=pretrained_model)
-
-    train_data, labels, train_files, train_probs = None, None, None, None
-    test_data, test_labels, test_files, test_probs = None, None, None, None
-    if len(args.file_list) == 0:
-        output = io.load_train_test_data(args.dir, args.test_dir, "_img", "_masks", 0)
-        images, labels, image_names, test_images, test_labels, image_names_test = output
-        train_data = []
-        for i in range(len(images)):
-            img = images[i].astype("float32")
-            if img.ndim > 2:
-                img = img[0]
-            train_data.append(
-                np.maximum(transforms.normalize99(img), 0)[np.newaxis, :, :])
-        if len(args.test_dir) > 0:
-            test_data = []
-            for i in range(len(test_images)):
-                img = test_images[i].astype("float32")
-                if img.ndim > 2:
-                    img = img[0]
-                test_data.append(
-                    np.maximum(transforms.normalize99(img), 0)[np.newaxis, :, :])
-        save_path = os.path.join(args.dir, "../models/")
-    else:
-        root = args.dir
-        denoise_logger.info(
-            ">>> using file_list (assumes images are normalized and have flows!)")
-        dat = np.load(args.file_list, allow_pickle=True).item()
-        train_files = dat["train_files"]
-        test_files = dat["test_files"]
-        train_probs = dat["train_probs"] if "train_probs" in dat else None
-        test_probs = dat["test_probs"] if "test_probs" in dat else None
-        if str(train_files[0])[:len(str(root))] != str(root):
-            for i in range(len(train_files)):
-                new_path = root / Path(*train_files[i].parts[-3:])
-                if i == 0:
-                    print(f"changing path from {train_files[i]} to {new_path}")
-                train_files[i] = new_path
-
-            for i in range(len(test_files)):
-                new_path = root / Path(*test_files[i].parts[-3:])
-                test_files[i] = new_path
-        save_path = os.path.join(args.dir, "models/")
-
-    os.makedirs(save_path, exist_ok=True)
-
-    nimg_per_epoch = None if args.nimg_per_epoch == 0 else args.nimg_per_epoch
-    nimg_test_per_epoch = None if args.nimg_test_per_epoch == 0 else args.nimg_test_per_epoch
-
-    model_path = train(
-        model.net, train_data=train_data, train_labels=labels, train_files=train_files,
-        test_data=test_data, test_labels=test_labels, test_files=test_files,
-        train_probs=train_probs, test_probs=test_probs, poisson=poisson, beta=beta,
-        blur=blur, gblur=gblur, downsample=downsample, ds_max=args.ds_max,
-        iso=iso, uniform_blur=uniform_blur, n_epochs=args.n_epochs,
-        learning_rate=args.learning_rate,
-        lam=lams, 
-        seg_model_type=args.seg_model_type, nimg_per_epoch=nimg_per_epoch,
-        nimg_test_per_epoch=nimg_test_per_epoch, save_path=save_path)
-
-
-def seg_train_noisy(model, train_data, train_labels, test_data=None, test_labels=None,
-                    poisson=0.8, blur=0.0, downsample=0.0, save_path=None,
-                    save_every=100, save_each=False, learning_rate=0.2, n_epochs=500,
-                    momentum=0.9, weight_decay=0.00001, SGD=True, batch_size=8,
-                    nimg_per_epoch=None, diameter=None, rescale=True, z_masking=False,
-                    model_name=None):
-    """ train function uses loss function model.loss_fn in models.py
-    
-    (data should already be normalized)
-
-    """
-
-    d = datetime.datetime.now()
-
-    model.n_epochs = n_epochs
-    if isinstance(learning_rate, (list, np.ndarray)):
-        if isinstance(learning_rate, np.ndarray) and learning_rate.ndim > 1:
-            raise ValueError("learning_rate.ndim must equal 1")
-        elif len(learning_rate) != n_epochs:
-            raise ValueError(
-                "if learning_rate given as list or np.ndarray it must have length n_epochs"
-            )
-        model.learning_rate = learning_rate
-        model.learning_rate_const = mode(learning_rate)[0][0]
-    else:
-        model.learning_rate_const = learning_rate
-        # set learning rate schedule
-        if SGD:
-            LR = np.linspace(0, model.learning_rate_const, 10)
-            if model.n_epochs > 250:
-                LR = np.append(
-                    LR, model.learning_rate_const * np.ones(model.n_epochs - 100))
-                for i in range(10):
-                    LR = np.append(LR, LR[-1] / 2 * np.ones(10))
-            else:
-                LR = np.append(
-                    LR,
-                    model.learning_rate_const * np.ones(max(0, model.n_epochs - 10)))
-        else:
-            LR = model.learning_rate_const * np.ones(model.n_epochs)
-        model.learning_rate = LR
-
-    model.batch_size = batch_size
-    model._set_optimizer(model.learning_rate[0], momentum, weight_decay, SGD)
-    model._set_criterion()
-
-    nimg = len(train_data)
-
-    # compute average cell diameter
-    if diameter is None:
-        diam_train = np.array(
-            [utils.diameters(train_labels[k][0])[0] for k in range(len(train_labels))])
-        diam_train_mean = diam_train[diam_train > 0].mean()
-        model.diam_labels = diam_train_mean
-        if rescale:
-            diam_train[diam_train < 5] = 5.
-            if test_data is not None:
-                diam_test = np.array([
-                    utils.diameters(test_labels[k][0])[0]
-                    for k in range(len(test_labels))
-                ])
-                diam_test[diam_test < 5] = 5.
-            denoise_logger.info(">>>> median diameter set to = %d" % model.diam_mean)
-    elif rescale:
-        diam_train_mean = diameter
-        model.diam_labels = diameter
-        denoise_logger.info(">>>> median diameter set to = %d" % model.diam_mean)
-        diam_train = diameter * np.ones(len(train_labels), "float32")
-        if test_data is not None:
-            diam_test = diameter * np.ones(len(test_labels), "float32")
-
-    denoise_logger.info(
-        f">>>> mean of training label mask diameters (saved to model) {diam_train_mean:.3f}"
-    )
-    model.net.diam_labels.data = torch.ones(1, device=model.device) * diam_train_mean
-
-    nchan = train_data[0].shape[0]
-    denoise_logger.info(">>>> training network with %d channel input <<<<" % nchan)
-    denoise_logger.info(">>>> LR: %0.5f, batch_size: %d, weight_decay: %0.5f" %
-                        (model.learning_rate_const, model.batch_size, weight_decay))
-
-    if test_data is not None:
-        denoise_logger.info(f">>>> ntrain = {nimg}, ntest = {len(test_data)}")
-    else:
-        denoise_logger.info(f">>>> ntrain = {nimg}")
-
-    tic = time.time()
-
-    lavg, nsum = 0, 0
-
-    if save_path is not None:
-        _, file_label = os.path.split(save_path)
-        file_path = os.path.join(save_path, "models/")
-
-        if not os.path.exists(file_path):
-            os.makedirs(file_path)
-    else:
-        denoise_logger.warning("WARNING: no save_path given, model not saving")
-
-    ksave = 0
-
-    # get indices for each epoch for training
-    np.random.seed(0)
-    inds_all = np.zeros((0,), "int32")
-    if nimg_per_epoch is None or nimg > nimg_per_epoch:
-        nimg_per_epoch = nimg
-    denoise_logger.info(f">>>> nimg_per_epoch = {nimg_per_epoch}")
-    while len(inds_all) < n_epochs * nimg_per_epoch:
-        rperm = np.random.permutation(nimg)
-        inds_all = np.hstack((inds_all, rperm))
-
-    for iepoch in range(model.n_epochs):
-        if SGD:
-            model._set_learning_rate(model.learning_rate[iepoch])
-        np.random.seed(iepoch)
-        rperm = inds_all[iepoch * nimg_per_epoch:(iepoch + 1) * nimg_per_epoch]
-        for ibatch in range(0, nimg_per_epoch, batch_size):
-            inds = rperm[ibatch:ibatch + batch_size]
-            imgi, lbl, scale = random_rotate_and_resize_noise(
-                [train_data[i] for i in inds], [train_labels[i][1:] for i in inds],
-                poisson=poisson, blur=blur, downsample=downsample,
-                diams=diam_train[inds], diam_mean=model.diam_mean)
-            imgi = imgi[:, :1]  # keep noisy only
-            if z_masking:
-                nc = imgi.shape[1]
-                nb = imgi.shape[0]
-                ncmin = (np.random.rand(nb) > 0.25) * (np.random.randint(
-                    nc // 2 - 1, size=nb))
-                ncmax = nc - (np.random.rand(nb) > 0.25) * (np.random.randint(
-                    nc // 2 - 1, size=nb))
-                for b in range(nb):
-                    imgi[b, :ncmin[b]] = 0
-                    imgi[b, ncmax[b]:] = 0
-
-            train_loss = model._train_step(imgi, lbl)
-            lavg += train_loss
-            nsum += len(imgi)
-
-        if iepoch % 10 == 0 or iepoch == 5:
-            lavg = lavg / nsum
-            if test_data is not None:
-                lavgt, nsum = 0., 0
-                np.random.seed(42)
-                rperm = np.arange(0, len(test_data), 1, int)
-                for ibatch in range(0, len(test_data), batch_size):
-                    inds = rperm[ibatch:ibatch + batch_size]
-                    imgi, lbl, scale = random_rotate_and_resize_noise(
-                        [test_data[i] for i in inds],
-                        [test_labels[i][1:] for i in inds], poisson=poisson, blur=blur,
-                        downsample=downsample, diams=diam_test[inds],
-                        diam_mean=model.diam_mean)
-                    imgi = imgi[:, :1]  # keep noisy only
-                    test_loss = model._test_eval(imgi, lbl)
-                    lavgt += test_loss
-                    nsum += len(imgi)
-
-                denoise_logger.info(
-                    "Epoch %d, Time %4.1fs, Loss %2.4f, Loss Test %2.4f, LR %2.4f" %
-                    (iepoch, time.time() - tic, lavg, lavgt / nsum,
-                     model.learning_rate[iepoch]))
-            else:
-                denoise_logger.info(
-                    "Epoch %d, Time %4.1fs, Loss %2.4f, LR %2.4f" %
-                    (iepoch, time.time() - tic, lavg, model.learning_rate[iepoch]))
-
-            lavg, nsum = 0, 0
-
-        if save_path is not None:
-            if iepoch == model.n_epochs - 1 or iepoch % save_every == 1:
-                # save model at the end
-                if save_each:  #separate files as model progresses
-                    if model_name is None:
-                        filename = "{}_{}_{}_{}".format(
-                            model.net_type, file_label,
-                            d.strftime("%Y_%m_%d_%H_%M_%S.%f"), "epoch_" + str(iepoch))
-                    else:
-                        filename = "{}_{}".format(model_name, "epoch_" + str(iepoch))
-                else:
-                    if model_name is None:
-                        filename = "{}_{}_{}".format(model.net_type, file_label,
-                                                     d.strftime("%Y_%m_%d_%H_%M_%S.%f"))
-                    else:
-                        filename = model_name
-                filename = os.path.join(file_path, filename)
-                ksave += 1
-                denoise_logger.info(f"saving network parameters to {filename}")
-                model.net.save_model(filename)
-        else:
-            filename = save_path
-
-    return filename

models/seg_post_model/cellpose/export.py

@@ -1,405 +0,0 @@
-"""Auxiliary module for bioimageio format export
-
-Example usage:
-
-```bash
-#!/bin/bash
-
-# Define default paths and parameters
-DEFAULT_CHANNELS="1 0"
-DEFAULT_PATH_PRETRAINED_MODEL="/home/qinyu/models/cp/cellpose_residual_on_style_on_concatenation_off_1135_rest_2023_05_04_23_41_31.252995"
-DEFAULT_PATH_README="/home/qinyu/models/cp/README.md"
-DEFAULT_LIST_PATH_COVER_IMAGES="/home/qinyu/images/cp/cellpose_raw_and_segmentation.jpg /home/qinyu/images/cp/cellpose_raw_and_probability.jpg /home/qinyu/images/cp/cellpose_raw.jpg"
-DEFAULT_MODEL_ID="philosophical-panda"
-DEFAULT_MODEL_ICON="🐼"
-DEFAULT_MODEL_VERSION="0.1.0"
-DEFAULT_MODEL_NAME="My Cool Cellpose"
-DEFAULT_MODEL_DOCUMENTATION="A cool Cellpose model trained for my cool dataset."
-DEFAULT_MODEL_AUTHORS='[{"name": "Qin Yu", "affiliation": "EMBL", "github_user": "qin-yu", "orcid": "0000-0002-4652-0795"}]'
-DEFAULT_MODEL_CITE='[{"text": "For more details of the model itself, see the manuscript", "doi": "10.1242/dev.202800", "url": null}]'
-DEFAULT_MODEL_TAGS="cellpose 3d 2d"
-DEFAULT_MODEL_LICENSE="MIT"
-DEFAULT_MODEL_REPO="https://github.com/kreshuklab/go-nuclear"
-
-# Run the Python script with default parameters
-python export.py \
-    --channels $DEFAULT_CHANNELS \
-    --path_pretrained_model "$DEFAULT_PATH_PRETRAINED_MODEL" \
-    --path_readme "$DEFAULT_PATH_README" \
-    --list_path_cover_images $DEFAULT_LIST_PATH_COVER_IMAGES \
-    --model_version "$DEFAULT_MODEL_VERSION" \
-    --model_name "$DEFAULT_MODEL_NAME" \
-    --model_documentation "$DEFAULT_MODEL_DOCUMENTATION" \
-    --model_authors "$DEFAULT_MODEL_AUTHORS" \
-    --model_cite "$DEFAULT_MODEL_CITE" \
-    --model_tags $DEFAULT_MODEL_TAGS \
-    --model_license "$DEFAULT_MODEL_LICENSE" \
-    --model_repo "$DEFAULT_MODEL_REPO"
-```
-"""
-
-import os
-import sys
-import json
-import argparse
-from pathlib import Path
-from urllib.parse import urlparse
-
-import torch
-import numpy as np
-
-from cellpose.io import imread
-from cellpose.utils import download_url_to_file
-from cellpose.transforms import pad_image_ND, normalize_img, convert_image
-from cellpose.vit_sam import CPnetBioImageIO
-
-from bioimageio.spec.model.v0_5 import (
-    ArchitectureFromFileDescr,
-    Author,
-    AxisId,
-    ChannelAxis,
-    CiteEntry,
-    Doi,
-    FileDescr,
-    Identifier,
-    InputTensorDescr,
-    IntervalOrRatioDataDescr,
-    LicenseId,
-    ModelDescr,
-    ModelId,
-    OrcidId,
-    OutputTensorDescr,
-    ParameterizedSize,
-    PytorchStateDictWeightsDescr,
-    SizeReference,
-    SpaceInputAxis,
-    SpaceOutputAxis,
-    TensorId,
-    TorchscriptWeightsDescr,
-    Version,
-    WeightsDescr,
-)
-# Define ARBITRARY_SIZE if it is not available in the module
-try:
-    from bioimageio.spec.model.v0_5 import ARBITRARY_SIZE
-except ImportError:
-    ARBITRARY_SIZE = ParameterizedSize(min=1, step=1)
-
-from bioimageio.spec.common import HttpUrl
-from bioimageio.spec import save_bioimageio_package
-from bioimageio.core import test_model
-
-DEFAULT_CHANNELS = [2, 1]
-DEFAULT_NORMALIZE_PARAMS = {
-    "axis": -1,
-    "lowhigh": None,
-    "percentile": None,
-    "normalize": True,
-    "norm3D": False,
-    "sharpen_radius": 0,
-    "smooth_radius": 0,
-    "tile_norm_blocksize": 0,
-    "tile_norm_smooth3D": 1,
-    "invert": False,
-}
-IMAGE_URL = "http://www.cellpose.org/static/data/rgb_3D.tif"
-
-
-def download_and_normalize_image(path_dir_temp, channels=DEFAULT_CHANNELS):
-    """
-    Download and normalize image.
-    """
-    filename = os.path.basename(urlparse(IMAGE_URL).path)
-    path_image = path_dir_temp / filename
-    if not path_image.exists():
-        sys.stderr.write(f'Downloading: "{IMAGE_URL}" to {path_image}\n')
-        download_url_to_file(IMAGE_URL, path_image)
-    img = imread(path_image).astype(np.float32)
-    img = convert_image(img, channels, channel_axis=1, z_axis=0, do_3D=False, nchan=2)
-    img = normalize_img(img, **DEFAULT_NORMALIZE_PARAMS)
-    img = np.transpose(img, (0, 3, 1, 2))
-    img, _, _ = pad_image_ND(img)
-    return img
-
-
-def load_bioimageio_cpnet_model(path_model_weight, nchan=2):
-    cpnet_kwargs = {
-        "nout": 3,
-    }
-    cpnet_biio = CPnetBioImageIO(**cpnet_kwargs)
-    state_dict_cuda = torch.load(path_model_weight, map_location=torch.device("cpu"), weights_only=True)
-    cpnet_biio.load_state_dict(state_dict_cuda)
-    cpnet_biio.eval()  # crucial for the prediction results
-    return cpnet_biio, cpnet_kwargs
-
-
-def descr_gen_input(path_test_input, nchan=2):
-    input_axes = [
-        SpaceInputAxis(id=AxisId("z"), size=ARBITRARY_SIZE),
-        ChannelAxis(channel_names=[Identifier(f"c{i+1}") for i in range(nchan)]),
-        SpaceInputAxis(id=AxisId("y"), size=ParameterizedSize(min=16, step=16)),
-        SpaceInputAxis(id=AxisId("x"), size=ParameterizedSize(min=16, step=16)),
-    ]
-    data_descr = IntervalOrRatioDataDescr(type="float32")
-    path_test_input = Path(path_test_input)
-    descr_input = InputTensorDescr(
-        id=TensorId("raw"),
-        axes=input_axes,
-        test_tensor=FileDescr(source=path_test_input),
-        data=data_descr,
-    )
-    return descr_input
-
-
-def descr_gen_output_flow(path_test_output):
-    output_axes_output_tensor = [
-        SpaceOutputAxis(id=AxisId("z"), size=SizeReference(tensor_id=TensorId("raw"), axis_id=AxisId("z"))),
-        ChannelAxis(channel_names=[Identifier("flow1"), Identifier("flow2"), Identifier("flow3")]),
-        SpaceOutputAxis(id=AxisId("y"), size=SizeReference(tensor_id=TensorId("raw"), axis_id=AxisId("y"))),
-        SpaceOutputAxis(id=AxisId("x"), size=SizeReference(tensor_id=TensorId("raw"), axis_id=AxisId("x"))),
-    ]
-    path_test_output = Path(path_test_output)
-    descr_output = OutputTensorDescr(
-        id=TensorId("flow"),
-        axes=output_axes_output_tensor,
-        test_tensor=FileDescr(source=path_test_output),
-    )
-    return descr_output
-
-
-def descr_gen_output_downsampled(path_dir_temp, nbase=None):
-    if nbase is None:
-        nbase = [32, 64, 128, 256]
-
-    output_axes_downsampled_tensors = [
-        [
-            SpaceOutputAxis(id=AxisId("z"), size=SizeReference(tensor_id=TensorId("raw"), axis_id=AxisId("z"))),
-            ChannelAxis(channel_names=[Identifier(f"feature{i+1}") for i in range(base)]),
-            SpaceOutputAxis(
-                id=AxisId("y"),
-                size=SizeReference(tensor_id=TensorId("raw"), axis_id=AxisId("y")),
-                scale=2**offset,
-            ),
-            SpaceOutputAxis(
-                id=AxisId("x"),
-                size=SizeReference(tensor_id=TensorId("raw"), axis_id=AxisId("x")),
-                scale=2**offset,
-            ),
-        ]
-        for offset, base in enumerate(nbase)
-    ]
-    path_downsampled_tensors = [
-        Path(path_dir_temp / f"test_downsampled_{i}.npy") for i in range(len(output_axes_downsampled_tensors))
-    ]
-    descr_output_downsampled_tensors = [
-        OutputTensorDescr(
-            id=TensorId(f"downsampled_{i}"),
-            axes=axes,
-            test_tensor=FileDescr(source=path),
-        )
-        for i, (axes, path) in enumerate(zip(output_axes_downsampled_tensors, path_downsampled_tensors))
-    ]
-    return descr_output_downsampled_tensors
-
-
-def descr_gen_output_style(path_test_style, nchannel=256):
-    output_axes_style_tensor = [
-        SpaceOutputAxis(id=AxisId("z"), size=SizeReference(tensor_id=TensorId("raw"), axis_id=AxisId("z"))),
-        ChannelAxis(channel_names=[Identifier(f"feature{i+1}") for i in range(nchannel)]),
-    ]
-    path_style_tensor = Path(path_test_style)
-    descr_output_style_tensor = OutputTensorDescr(
-        id=TensorId("style"),
-        axes=output_axes_style_tensor,
-        test_tensor=FileDescr(source=path_style_tensor),
-    )
-    return descr_output_style_tensor
-
-
-def descr_gen_arch(cpnet_kwargs, path_cpnet_wrapper=None):
-    if path_cpnet_wrapper is None:
-        path_cpnet_wrapper = Path(__file__).parent / "resnet_torch.py"
-    pytorch_architecture = ArchitectureFromFileDescr(
-        callable=Identifier("CPnetBioImageIO"),
-        source=Path(path_cpnet_wrapper),
-        kwargs=cpnet_kwargs,
-    )
-    return pytorch_architecture
-
-
-def descr_gen_documentation(path_doc, markdown_text):
-    with open(path_doc, "w") as f:
-        f.write(markdown_text)
-
-
-def package_to_bioimageio(
-    path_pretrained_model,
-    path_save_trace,
-    path_readme,
-    list_path_cover_images,
-    descr_input,
-    descr_output,
-    descr_output_downsampled_tensors,
-    descr_output_style_tensor,
-    pytorch_version,
-    pytorch_architecture,
-    model_id,
-    model_icon,
-    model_version,
-    model_name,
-    model_documentation,
-    model_authors,
-    model_cite,
-    model_tags,
-    model_license,
-    model_repo,
-):
-    """Package model description to BioImage.IO format."""
-    my_model_descr = ModelDescr(
-        id=ModelId(model_id) if model_id is not None else None,
-        id_emoji=model_icon,
-        version=Version(model_version),
-        name=model_name,
-        description=model_documentation,
-        authors=[
-            Author(
-                name=author["name"],
-                affiliation=author["affiliation"],
-                github_user=author["github_user"],
-                orcid=OrcidId(author["orcid"]),
-            )
-            for author in model_authors
-        ],
-        cite=[CiteEntry(text=cite["text"], doi=Doi(cite["doi"]), url=cite["url"]) for cite in model_cite],
-        covers=[Path(img) for img in list_path_cover_images],
-        license=LicenseId(model_license),
-        tags=model_tags,
-        documentation=Path(path_readme),
-        git_repo=HttpUrl(model_repo),
-        inputs=[descr_input],
-        outputs=[descr_output, descr_output_style_tensor] + descr_output_downsampled_tensors,
-        weights=WeightsDescr(
-            pytorch_state_dict=PytorchStateDictWeightsDescr(
-                source=Path(path_pretrained_model),
-                architecture=pytorch_architecture,
-                pytorch_version=pytorch_version,
-            ),
-            torchscript=TorchscriptWeightsDescr(
-                source=Path(path_save_trace),
-                pytorch_version=pytorch_version,
-                parent="pytorch_state_dict",  # these weights were converted from the pytorch_state_dict weights.
-            ),
-        ),
-    )
-
-    return my_model_descr
-
-
-def parse_args():
-    # fmt: off
-    parser = argparse.ArgumentParser(description="BioImage.IO model packaging for Cellpose")
-    parser.add_argument("--channels", nargs=2, default=[2, 1], type=int, help="Cyto-only = [2, 0], Cyto + Nuclei = [2, 1], Nuclei-only = [1, 0]")
-    parser.add_argument("--path_pretrained_model", required=True, type=str, help="Path to pretrained model file, e.g., cellpose_residual_on_style_on_concatenation_off_1135_rest_2023_05_04_23_41_31.252995")
-    parser.add_argument("--path_readme", required=True, type=str, help="Path to README file")
-    parser.add_argument("--list_path_cover_images", nargs='+', required=True, type=str, help="List of paths to cover images")
-    parser.add_argument("--model_id", type=str, help="Model ID, provide if already exists", default=None)
-    parser.add_argument("--model_icon", type=str, help="Model icon, provide if already exists", default=None)
-    parser.add_argument("--model_version", required=True, type=str, help="Model version, new model should be 0.1.0")
-    parser.add_argument("--model_name", required=True, type=str, help="Model name, e.g., My Cool Cellpose")
-    parser.add_argument("--model_documentation", required=True, type=str, help="Model documentation, e.g., A cool Cellpose model trained for my cool dataset.")
-    parser.add_argument("--model_authors", required=True, type=str, help="Model authors in JSON format, e.g., '[{\"name\": \"Qin Yu\", \"affiliation\": \"EMBL\", \"github_user\": \"qin-yu\", \"orcid\": \"0000-0002-4652-0795\"}]'")
-    parser.add_argument("--model_cite", required=True, type=str, help="Model citation in JSON format, e.g., '[{\"text\": \"For more details of the model itself, see the manuscript\", \"doi\": \"10.1242/dev.202800\", \"url\": null}]'")
-    parser.add_argument("--model_tags", nargs='+', required=True, type=str, help="Model tags, e.g., cellpose 3d 2d")
-    parser.add_argument("--model_license", required=True, type=str, help="Model license, e.g., MIT")
-    parser.add_argument("--model_repo", required=True, type=str, help="Model repository URL")
-    return parser.parse_args()
-    # fmt: on
-
-
-def main():
-    args = parse_args()
-
-    # Parse user-provided paths and arguments
-    channels = args.channels
-    model_cite = json.loads(args.model_cite)
-    model_authors = json.loads(args.model_authors)
-
-    path_readme = Path(args.path_readme)
-    path_pretrained_model = Path(args.path_pretrained_model)
-    list_path_cover_images = [Path(path_image) for path_image in args.list_path_cover_images]
-
-    # Auto-generated paths
-    path_cpnet_wrapper = Path(__file__).resolve().parent / "resnet_torch.py"
-    path_dir_temp = Path(__file__).resolve().parent.parent / "models" / path_pretrained_model.stem
-    path_dir_temp.mkdir(parents=True, exist_ok=True)
-
-    path_save_trace = path_dir_temp / "cp_traced.pt"
-    path_test_input = path_dir_temp / "test_input.npy"
-    path_test_output = path_dir_temp / "test_output.npy"
-    path_test_style = path_dir_temp / "test_style.npy"
-    path_bioimageio_package = path_dir_temp / "cellpose_model.zip"
-
-    # Download test input image
-    img_np = download_and_normalize_image(path_dir_temp, channels=channels)
-    np.save(path_test_input, img_np)
-    img = torch.tensor(img_np).float()
-
-    # Load model
-    cpnet_biio, cpnet_kwargs = load_bioimageio_cpnet_model(path_pretrained_model)
-
-    # Test model and save output
-    tuple_output_tensor = cpnet_biio(img)
-    np.save(path_test_output, tuple_output_tensor[0].detach().numpy())
-    np.save(path_test_style, tuple_output_tensor[1].detach().numpy())
-    for i, t in enumerate(tuple_output_tensor[2:]):
-        np.save(path_dir_temp / f"test_downsampled_{i}.npy", t.detach().numpy())
-
-    # Save traced model
-    model_traced = torch.jit.trace(cpnet_biio, img)
-    model_traced.save(path_save_trace)
-
-    # Generate model description
-    descr_input = descr_gen_input(path_test_input)
-    descr_output = descr_gen_output_flow(path_test_output)
-    descr_output_downsampled_tensors = descr_gen_output_downsampled(path_dir_temp, nbase=cpnet_biio.nbase[1:])
-    descr_output_style_tensor = descr_gen_output_style(path_test_style, cpnet_biio.nbase[-1])
-    pytorch_version = Version(torch.__version__)
-    pytorch_architecture = descr_gen_arch(cpnet_kwargs, path_cpnet_wrapper)
-
-    # Package model
-    my_model_descr = package_to_bioimageio(
-        path_pretrained_model,
-        path_save_trace,
-        path_readme,
-        list_path_cover_images,
-        descr_input,
-        descr_output,
-        descr_output_downsampled_tensors,
-        descr_output_style_tensor,
-        pytorch_version,
-        pytorch_architecture,
-        args.model_id,
-        args.model_icon,
-        args.model_version,
-        args.model_name,
-        args.model_documentation,
-        model_authors,
-        model_cite,
-        args.model_tags,
-        args.model_license,
-        args.model_repo,
-    )
-
-    # Test model
-    summary = test_model(my_model_descr, weight_format="pytorch_state_dict")
-    summary.display()
-    summary = test_model(my_model_descr, weight_format="torchscript")
-    summary.display()
-
-    # Save BioImage.IO package
-    package_path = save_bioimageio_package(my_model_descr, output_path=Path(path_bioimageio_package))
-    print("package path:", package_path)
-
-
-if __name__ == "__main__":
-    main()

models/seg_post_model/cellpose/gui/gui.py

@@ -1,2007 +0,0 @@
-"""
-Copyright © 2025 Howard Hughes Medical Institute, Authored by Carsen Stringer, Michael Rariden and Marius Pachitariu.
-"""
-
-import sys, os, pathlib, warnings, datetime, time, copy
-
-from qtpy import QtGui, QtCore
-from superqt import QRangeSlider, QCollapsible
-from qtpy.QtWidgets import QScrollArea, QMainWindow, QApplication, QWidget, QScrollBar, \
-    QComboBox, QGridLayout, QPushButton, QFrame, QCheckBox, QLabel, QProgressBar, \
-        QLineEdit, QMessageBox, QGroupBox, QMenu, QAction
-import pyqtgraph as pg
-
-import numpy as np
-from scipy.stats import mode
-import cv2
-
-from . import guiparts, menus, io
-from .. import models, core, dynamics, version, train
-from ..utils import download_url_to_file, masks_to_outlines, diameters
-from ..io import get_image_files, imsave, imread
-from ..transforms import resize_image, normalize99, normalize99_tile, smooth_sharpen_img
-from ..models import normalize_default
-from ..plot import disk
-
-try:
-    import matplotlib.pyplot as plt
-    MATPLOTLIB = True
-except:
-    MATPLOTLIB = False
-
-Horizontal = QtCore.Qt.Orientation.Horizontal
-
-
-class Slider(QRangeSlider):
-
-    def __init__(self, parent, name, color):
-        super().__init__(Horizontal)
-        self.setEnabled(False)
-        self.valueChanged.connect(lambda: self.levelChanged(parent))
-        self.name = name
-
-        self.setStyleSheet(""" QSlider{
-                             background-color: transparent;
-                             }
-        """)
-        self.show()
-
-    def levelChanged(self, parent):
-        parent.level_change(self.name)
-
-
-class QHLine(QFrame):
-
-    def __init__(self):
-        super(QHLine, self).__init__()
-        self.setFrameShape(QFrame.HLine)
-        self.setLineWidth(8)
-
-
-def make_bwr():
-    # make a bwr colormap
-    b = np.append(255 * np.ones(128), np.linspace(0, 255, 128)[::-1])[:, np.newaxis]
-    r = np.append(np.linspace(0, 255, 128), 255 * np.ones(128))[:, np.newaxis]
-    g = np.append(np.linspace(0, 255, 128),
-                  np.linspace(0, 255, 128)[::-1])[:, np.newaxis]
-    color = np.concatenate((r, g, b), axis=-1).astype(np.uint8)
-    bwr = pg.ColorMap(pos=np.linspace(0.0, 255, 256), color=color)
-    return bwr
-
-
-def make_spectral():
-    # make spectral colormap
-    r = np.array([
-        0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80,
-        84, 88, 92, 96, 100, 104, 108, 112, 116, 120, 124, 128, 128, 128, 128, 128, 128,
-        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 120, 112, 104, 96, 88,
-        80, 72, 64, 56, 48, 40, 32, 24, 16, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 7, 11, 15, 19, 23,
-        27, 31, 35, 39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83, 87, 91, 95, 99, 103,
-        107, 111, 115, 119, 123, 127, 131, 135, 139, 143, 147, 151, 155, 159, 163, 167,
-        171, 175, 179, 183, 187, 191, 195, 199, 203, 207, 211, 215, 219, 223, 227, 231,
-        235, 239, 243, 247, 251, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255
-    ])
-    g = np.array([
-        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 9, 8, 8, 7, 7, 6, 6, 5, 5, 5, 4, 4, 3, 3,
-        2, 2, 1, 1, 0, 0, 0, 7, 15, 23, 31, 39, 47, 55, 63, 71, 79, 87, 95, 103, 111,
-        119, 127, 135, 143, 151, 159, 167, 175, 183, 191, 199, 207, 215, 223, 231, 239,
-        247, 255, 247, 239, 231, 223, 215, 207, 199, 191, 183, 175, 167, 159, 151, 143,
-        135, 128, 129, 131, 132, 134, 135, 137, 139, 140, 142, 143, 145, 147, 148, 150,
-        151, 153, 154, 156, 158, 159, 161, 162, 164, 166, 167, 169, 170, 172, 174, 175,
-        177, 178, 180, 181, 183, 185, 186, 188, 189, 191, 193, 194, 196, 197, 199, 201,
-        202, 204, 205, 207, 208, 210, 212, 213, 215, 216, 218, 220, 221, 223, 224, 226,
-        228, 229, 231, 232, 234, 235, 237, 239, 240, 242, 243, 245, 247, 248, 250, 251,
-        253, 255, 251, 247, 243, 239, 235, 231, 227, 223, 219, 215, 211, 207, 203, 199,
-        195, 191, 187, 183, 179, 175, 171, 167, 163, 159, 155, 151, 147, 143, 139, 135,
-        131, 127, 123, 119, 115, 111, 107, 103, 99, 95, 91, 87, 83, 79, 75, 71, 67, 63,
-        59, 55, 51, 47, 43, 39, 35, 31, 27, 23, 19, 15, 11, 7, 3, 0, 8, 16, 24, 32, 41,
-        49, 57, 65, 74, 82, 90, 98, 106, 115, 123, 131, 139, 148, 156, 164, 172, 180,
-        189, 197, 205, 213, 222, 230, 238, 246, 254
-    ])
-    b = np.array([
-        0, 7, 15, 23, 31, 39, 47, 55, 63, 71, 79, 87, 95, 103, 111, 119, 127, 135, 143,
-        151, 159, 167, 175, 183, 191, 199, 207, 215, 223, 231, 239, 247, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 251, 247,
-        243, 239, 235, 231, 227, 223, 219, 215, 211, 207, 203, 199, 195, 191, 187, 183,
-        179, 175, 171, 167, 163, 159, 155, 151, 147, 143, 139, 135, 131, 128, 126, 124,
-        122, 120, 118, 116, 114, 112, 110, 108, 106, 104, 102, 100, 98, 96, 94, 92, 90,
-        88, 86, 84, 82, 80, 78, 76, 74, 72, 70, 68, 66, 64, 62, 60, 58, 56, 54, 52, 50,
-        48, 46, 44, 42, 40, 38, 36, 34, 32, 30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10,
-        8, 6, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 16, 24, 32, 41, 49, 57, 65, 74,
-        82, 90, 98, 106, 115, 123, 131, 139, 148, 156, 164, 172, 180, 189, 197, 205,
-        213, 222, 230, 238, 246, 254
-    ])
-    color = (np.vstack((r, g, b)).T).astype(np.uint8)
-    spectral = pg.ColorMap(pos=np.linspace(0.0, 255, 256), color=color)
-    return spectral
-
-
-def make_cmap(cm=0):
-    # make a single channel colormap
-    r = np.arange(0, 256)
-    color = np.zeros((256, 3))
-    color[:, cm] = r
-    color = color.astype(np.uint8)
-    cmap = pg.ColorMap(pos=np.linspace(0.0, 255, 256), color=color)
-    return cmap
-
-
-def run(image=None):
-    from ..io import logger_setup
-    logger, log_file = logger_setup()
-    # Always start by initializing Qt (only once per application)
-    warnings.filterwarnings("ignore")
-    app = QApplication(sys.argv)
-    icon_path = pathlib.Path.home().joinpath(".cellpose", "logo.png")
-    guip_path = pathlib.Path.home().joinpath(".cellpose", "cellposeSAM_gui.png")
-    if not icon_path.is_file():
-        cp_dir = pathlib.Path.home().joinpath(".cellpose")
-        cp_dir.mkdir(exist_ok=True)
-        print("downloading logo")
-        download_url_to_file(
-            "https://www.cellpose.org/static/images/cellpose_transparent.png",
-            icon_path, progress=True)
-    if not guip_path.is_file():
-        print("downloading help window image")
-        download_url_to_file("https://www.cellpose.org/static/images/cellposeSAM_gui.png",
-                             guip_path, progress=True)
-    icon_path = str(icon_path.resolve())
-    app_icon = QtGui.QIcon()
-    app_icon.addFile(icon_path, QtCore.QSize(16, 16))
-    app_icon.addFile(icon_path, QtCore.QSize(24, 24))
-    app_icon.addFile(icon_path, QtCore.QSize(32, 32))
-    app_icon.addFile(icon_path, QtCore.QSize(48, 48))
-    app_icon.addFile(icon_path, QtCore.QSize(64, 64))
-    app_icon.addFile(icon_path, QtCore.QSize(256, 256))
-    app.setWindowIcon(app_icon)
-    app.setStyle("Fusion")
-    app.setPalette(guiparts.DarkPalette())
-    MainW(image=image, logger=logger)
-    ret = app.exec_()
-    sys.exit(ret)
-
-
-class MainW(QMainWindow):
-
-    def __init__(self, image=None, logger=None):
-        super(MainW, self).__init__()
-
-        self.logger = logger
-        pg.setConfigOptions(imageAxisOrder="row-major")
-        self.setGeometry(50, 50, 1200, 1000)
-        self.setWindowTitle(f"cellpose v{version}")
-        self.cp_path = os.path.dirname(os.path.realpath(__file__))
-        app_icon = QtGui.QIcon()
-        icon_path = pathlib.Path.home().joinpath(".cellpose", "logo.png")
-        icon_path = str(icon_path.resolve())
-        app_icon.addFile(icon_path, QtCore.QSize(16, 16))
-        app_icon.addFile(icon_path, QtCore.QSize(24, 24))
-        app_icon.addFile(icon_path, QtCore.QSize(32, 32))
-        app_icon.addFile(icon_path, QtCore.QSize(48, 48))
-        app_icon.addFile(icon_path, QtCore.QSize(64, 64))
-        app_icon.addFile(icon_path, QtCore.QSize(256, 256))
-        self.setWindowIcon(app_icon)
-        # rgb(150,255,150)
-        self.setStyleSheet(guiparts.stylesheet())
-
-        menus.mainmenu(self)
-        menus.editmenu(self)
-        menus.modelmenu(self)
-        menus.helpmenu(self)
-
-        self.stylePressed = """QPushButton {Text-align: center; 
-                             background-color: rgb(150,50,150); 
-                             border-color: white;
-                             color:white;}
-                            QToolTip { 
-                           background-color: black; 
-                           color: white; 
-                           border: black solid 1px
-                           }"""
-        self.styleUnpressed = """QPushButton {Text-align: center; 
-                               background-color: rgb(50,50,50);
-                                border-color: white;
-                               color:white;}
-                                QToolTip { 
-                           background-color: black; 
-                           color: white; 
-                           border: black solid 1px
-                           }"""
-        self.loaded = False
-
-        # ---- MAIN WIDGET LAYOUT ---- #
-        self.cwidget = QWidget(self)
-        self.lmain = QGridLayout()
-        self.cwidget.setLayout(self.lmain)
-        self.setCentralWidget(self.cwidget)
-        self.lmain.setVerticalSpacing(0)
-        self.lmain.setContentsMargins(0, 0, 0, 10)
-
-        self.imask = 0
-        self.scrollarea = QScrollArea()
-        self.scrollarea.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
-        self.scrollarea.setStyleSheet("""QScrollArea { border: none }""")
-        self.scrollarea.setWidgetResizable(True)
-        self.swidget = QWidget(self)
-        self.scrollarea.setWidget(self.swidget)
-        self.l0 = QGridLayout()
-        self.swidget.setLayout(self.l0)
-        b = self.make_buttons()
-        self.lmain.addWidget(self.scrollarea, 0, 0, 39, 9)
-
-        # ---- drawing area ---- #
-        self.win = pg.GraphicsLayoutWidget()
-
-        self.lmain.addWidget(self.win, 0, 9, 40, 30)
-
-        self.win.scene().sigMouseClicked.connect(self.plot_clicked)
-        self.win.scene().sigMouseMoved.connect(self.mouse_moved)
-        self.make_viewbox()
-        self.lmain.setColumnStretch(10, 1)
-        bwrmap = make_bwr()
-        self.bwr = bwrmap.getLookupTable(start=0.0, stop=255.0, alpha=False)
-        self.cmap = []
-        # spectral colormap
-        self.cmap.append(make_spectral().getLookupTable(start=0.0, stop=255.0,
-                                                        alpha=False))
-        # single channel colormaps
-        for i in range(3):
-            self.cmap.append(
-                make_cmap(i).getLookupTable(start=0.0, stop=255.0, alpha=False))
-
-        if MATPLOTLIB:
-            self.colormap = (plt.get_cmap("gist_ncar")(np.linspace(0.0, .9, 1000000)) *
-                             255).astype(np.uint8)
-            np.random.seed(42)  # make colors stable
-            self.colormap = self.colormap[np.random.permutation(1000000)]
-        else:
-            np.random.seed(42)  # make colors stable
-            self.colormap = ((np.random.rand(1000000, 3) * 0.8 + 0.1) * 255).astype(
-                np.uint8)
-        self.NZ = 1
-        self.restore = None
-        self.ratio = 1.
-        self.reset()
-
-        # This needs to go after .reset() is called to get state fully set up:
-        self.autobtn.checkStateChanged.connect(self.compute_saturation_if_checked)
-
-        self.load_3D = False
-
-        # if called with image, load it
-        if image is not None:
-            self.filename = image
-            io._load_image(self, self.filename)
-
-        # training settings
-        d = datetime.datetime.now()
-        self.training_params = {
-            "model_index": 0,
-            "learning_rate": 1e-5,
-            "weight_decay": 0.1,
-            "n_epochs": 100,
-            "model_name": "cpsam" + d.strftime("_%Y%m%d_%H%M%S"),
-        }
-
-        self.stitch_threshold = 0.
-        self.flow3D_smooth = 0.
-        self.anisotropy = 1.
-        self.min_size = 15
-
-        self.setAcceptDrops(True)
-        self.win.show()
-        self.show()
-
-    def help_window(self):
-        HW = guiparts.HelpWindow(self)
-        HW.show()
-
-    def train_help_window(self):
-        THW = guiparts.TrainHelpWindow(self)
-        THW.show()
-
-    def gui_window(self):
-        EG = guiparts.ExampleGUI(self)
-        EG.show()
-
-    def make_buttons(self):
-        self.boldfont = QtGui.QFont("Arial", 11, QtGui.QFont.Bold)
-        self.boldmedfont = QtGui.QFont("Arial", 9, QtGui.QFont.Bold)
-        self.medfont = QtGui.QFont("Arial", 9)
-        self.smallfont = QtGui.QFont("Arial", 8)
-
-        b = 0
-        self.satBox = QGroupBox("Views")
-        self.satBox.setFont(self.boldfont)
-        self.satBoxG = QGridLayout()
-        self.satBox.setLayout(self.satBoxG)
-        self.l0.addWidget(self.satBox, b, 0, 1, 9)
-
-        widget_row = 0
-        self.view = 0  # 0=image, 1=flowsXY, 2=flowsZ, 3=cellprob
-        self.color = 0  # 0=RGB, 1=gray, 2=R, 3=G, 4=B
-        self.RGBDropDown = QComboBox()
-        self.RGBDropDown.addItems(
-            ["RGB", "red=R", "green=G", "blue=B", "gray", "spectral"])
-        self.RGBDropDown.setFont(self.medfont)
-        self.RGBDropDown.currentIndexChanged.connect(self.color_choose)
-        self.satBoxG.addWidget(self.RGBDropDown, widget_row, 0, 1, 3)
-
-        label = QLabel("<p>[&uarr; / &darr; or W/S]</p>")
-        label.setFont(self.smallfont)
-        self.satBoxG.addWidget(label, widget_row, 3, 1, 3)
-        label = QLabel("[R / G / B \n toggles color ]")
-        label.setFont(self.smallfont)
-        self.satBoxG.addWidget(label, widget_row, 6, 1, 3)
-
-        widget_row += 1
-        self.ViewDropDown = QComboBox()
-        self.ViewDropDown.addItems(["image", "gradXY", "cellprob", "restored"])
-        self.ViewDropDown.setFont(self.medfont)
-        self.ViewDropDown.model().item(3).setEnabled(False)
-        self.ViewDropDown.currentIndexChanged.connect(self.update_plot)
-        self.satBoxG.addWidget(self.ViewDropDown, widget_row, 0, 2, 3)
-
-        label = QLabel("[pageup / pagedown]")
-        label.setFont(self.smallfont)
-        self.satBoxG.addWidget(label, widget_row, 3, 1, 5)
-
-        widget_row += 2
-        label = QLabel("")
-        label.setToolTip(
-            "NOTE: manually changing the saturation bars does not affect normalization in segmentation"
-        )
-        self.satBoxG.addWidget(label, widget_row, 0, 1, 5)
-
-        self.autobtn = QCheckBox("auto-adjust saturation")
-        self.autobtn.setToolTip("sets scale-bars as normalized for segmentation")
-        self.autobtn.setFont(self.medfont)
-        self.autobtn.setChecked(True)
-        self.satBoxG.addWidget(self.autobtn, widget_row, 1, 1, 8)
-
-        widget_row += 1
-        self.sliders = []
-        colors = [[255, 0, 0], [0, 255, 0], [0, 0, 255], [100, 100, 100]]
-        colornames = ["red", "Chartreuse", "DodgerBlue"]
-        names = ["red", "green", "blue"]
-        for r in range(3):
-            widget_row += 1
-            if r == 0:
-                label = QLabel('<font color="gray">gray/</font><br>red')
-            else:
-                label = QLabel(names[r] + ":")
-            label.setStyleSheet(f"color: {colornames[r]}")
-            label.setFont(self.boldmedfont)
-            self.satBoxG.addWidget(label, widget_row, 0, 1, 2)
-            self.sliders.append(Slider(self, names[r], colors[r]))
-            self.sliders[-1].setMinimum(-.1)
-            self.sliders[-1].setMaximum(255.1)
-            self.sliders[-1].setValue([0, 255])
-            self.sliders[-1].setToolTip(
-                "NOTE: manually changing the saturation bars does not affect normalization in segmentation"
-            )
-            self.satBoxG.addWidget(self.sliders[-1], widget_row, 2, 1, 7)
-
-        b += 1
-        self.drawBox = QGroupBox("Drawing")
-        self.drawBox.setFont(self.boldfont)
-        self.drawBoxG = QGridLayout()
-        self.drawBox.setLayout(self.drawBoxG)
-        self.l0.addWidget(self.drawBox, b, 0, 1, 9)
-        self.autosave = True
-
-        widget_row = 0
-        self.brush_size = 3
-        self.BrushChoose = QComboBox()
-        self.BrushChoose.addItems(["1", "3", "5", "7", "9"])
-        self.BrushChoose.currentIndexChanged.connect(self.brush_choose)
-        self.BrushChoose.setFixedWidth(40)
-        self.BrushChoose.setFont(self.medfont)
-        self.drawBoxG.addWidget(self.BrushChoose, widget_row, 3, 1, 2)
-        label = QLabel("brush size:")
-        label.setFont(self.medfont)
-        self.drawBoxG.addWidget(label, widget_row, 0, 1, 3)
-
-        widget_row += 1
-        # turn off masks
-        self.layer_off = False
-        self.masksOn = True
-        self.MCheckBox = QCheckBox("MASKS ON [X]")
-        self.MCheckBox.setFont(self.medfont)
-        self.MCheckBox.setChecked(True)
-        self.MCheckBox.toggled.connect(self.toggle_masks)
-        self.drawBoxG.addWidget(self.MCheckBox, widget_row, 0, 1, 5)
-
-        widget_row += 1
-        # turn off outlines
-        self.outlinesOn = False  # turn off by default
-        self.OCheckBox = QCheckBox("outlines on [Z]")
-        self.OCheckBox.setFont(self.medfont)
-        self.drawBoxG.addWidget(self.OCheckBox, widget_row, 0, 1, 5)
-        self.OCheckBox.setChecked(False)
-        self.OCheckBox.toggled.connect(self.toggle_masks)
-
-        widget_row += 1
-        self.SCheckBox = QCheckBox("single stroke")
-        self.SCheckBox.setFont(self.medfont)
-        self.SCheckBox.setChecked(True)
-        self.SCheckBox.toggled.connect(self.autosave_on)
-        self.SCheckBox.setEnabled(True)
-        self.drawBoxG.addWidget(self.SCheckBox, widget_row, 0, 1, 5)
-
-        # buttons for deleting multiple cells
-        self.deleteBox = QGroupBox("delete multiple ROIs")
-        self.deleteBox.setStyleSheet("color: rgb(200, 200, 200)")
-        self.deleteBox.setFont(self.medfont)
-        self.deleteBoxG = QGridLayout()
-        self.deleteBox.setLayout(self.deleteBoxG)
-        self.drawBoxG.addWidget(self.deleteBox, 0, 5, 4, 4)
-        self.MakeDeletionRegionButton = QPushButton("region-select")
-        self.MakeDeletionRegionButton.clicked.connect(self.remove_region_cells)
-        self.deleteBoxG.addWidget(self.MakeDeletionRegionButton, 0, 0, 1, 4)
-        self.MakeDeletionRegionButton.setFont(self.smallfont)
-        self.MakeDeletionRegionButton.setFixedWidth(70)
-        self.DeleteMultipleROIButton = QPushButton("click-select")
-        self.DeleteMultipleROIButton.clicked.connect(self.delete_multiple_cells)
-        self.deleteBoxG.addWidget(self.DeleteMultipleROIButton, 1, 0, 1, 4)
-        self.DeleteMultipleROIButton.setFont(self.smallfont)
-        self.DeleteMultipleROIButton.setFixedWidth(70)
-        self.DoneDeleteMultipleROIButton = QPushButton("done")
-        self.DoneDeleteMultipleROIButton.clicked.connect(
-            self.done_remove_multiple_cells)
-        self.deleteBoxG.addWidget(self.DoneDeleteMultipleROIButton, 2, 0, 1, 2)
-        self.DoneDeleteMultipleROIButton.setFont(self.smallfont)
-        self.DoneDeleteMultipleROIButton.setFixedWidth(35)
-        self.CancelDeleteMultipleROIButton = QPushButton("cancel")
-        self.CancelDeleteMultipleROIButton.clicked.connect(self.cancel_remove_multiple)
-        self.deleteBoxG.addWidget(self.CancelDeleteMultipleROIButton, 2, 2, 1, 2)
-        self.CancelDeleteMultipleROIButton.setFont(self.smallfont)
-        self.CancelDeleteMultipleROIButton.setFixedWidth(35)
-
-        b += 1
-        widget_row = 0
-        self.segBox = QGroupBox("Segmentation")
-        self.segBoxG = QGridLayout()
-        self.segBox.setLayout(self.segBoxG)
-        self.l0.addWidget(self.segBox, b, 0, 1, 9)
-        self.segBox.setFont(self.boldfont)
-
-        widget_row += 1
-
-        # use GPU
-        self.useGPU = QCheckBox("use GPU")
-        self.useGPU.setToolTip(
-            "if you have specially installed the <i>cuda</i> version of torch, then you can activate this"
-        )
-        self.useGPU.setFont(self.medfont)
-        self.check_gpu()
-        self.segBoxG.addWidget(self.useGPU, widget_row, 0, 1, 3)
-
-        # compute segmentation with general models
-        self.net_text = ["run CPSAM"]
-        nett = ["cellpose super-generalist model"]
-
-        self.StyleButtons = []
-        jj = 4
-        for j in range(len(self.net_text)):
-            self.StyleButtons.append(
-                guiparts.ModelButton(self, self.net_text[j], self.net_text[j]))
-            w = 5
-            self.segBoxG.addWidget(self.StyleButtons[-1], widget_row, jj, 1, w)
-            jj += w
-            self.StyleButtons[-1].setToolTip(nett[j])
-
-        widget_row += 1
-        self.ncells = guiparts.ObservableVariable(0)
-        self.roi_count = QLabel()
-        self.roi_count.setFont(self.boldfont)
-        self.roi_count.setAlignment(QtCore.Qt.AlignLeft)
-        self.ncells.valueChanged.connect(
-            lambda n: self.roi_count.setText(f'{str(n)} ROIs')
-        )
-
-        self.segBoxG.addWidget(self.roi_count, widget_row, 0, 1, 4)
-
-        self.progress = QProgressBar(self)
-        self.segBoxG.addWidget(self.progress, widget_row, 4, 1, 5)
-
-        widget_row += 1
-
-        ############################### Segmentation settings ###############################
-        self.additional_seg_settings_qcollapsible = QCollapsible("additional settings")
-        self.additional_seg_settings_qcollapsible.setFont(self.medfont)
-        self.additional_seg_settings_qcollapsible._toggle_btn.setFont(self.medfont)
-        self.segmentation_settings = guiparts.SegmentationSettings(self.medfont)
-        self.additional_seg_settings_qcollapsible.setContent(self.segmentation_settings)
-        self.segBoxG.addWidget(self.additional_seg_settings_qcollapsible, widget_row, 0, 1, 9)
-
-        # connect edits to image processing steps: 
-        self.segmentation_settings.diameter_box.editingFinished.connect(self.update_scale)
-        self.segmentation_settings.flow_threshold_box.returnPressed.connect(self.compute_cprob)
-        self.segmentation_settings.cellprob_threshold_box.returnPressed.connect(self.compute_cprob)
-        self.segmentation_settings.niter_box.returnPressed.connect(self.compute_cprob)
-
-        # Needed to do this for the drop down to not be open on startup
-        self.additional_seg_settings_qcollapsible._toggle_btn.setChecked(True)
-        self.additional_seg_settings_qcollapsible._toggle_btn.setChecked(False)
-
-        b += 1
-        self.modelBox = QGroupBox("user-trained models")
-        self.modelBoxG = QGridLayout()
-        self.modelBox.setLayout(self.modelBoxG)
-        self.l0.addWidget(self.modelBox, b, 0, 1, 9)
-        self.modelBox.setFont(self.boldfont)
-        # choose models
-        self.ModelChooseC = QComboBox()
-        self.ModelChooseC.setFont(self.medfont)
-        current_index = 0
-        self.ModelChooseC.addItems(["custom models"])
-        if len(self.model_strings) > 0:
-            self.ModelChooseC.addItems(self.model_strings)
-        self.ModelChooseC.setFixedWidth(175)
-        self.ModelChooseC.setCurrentIndex(current_index)
-        tipstr = 'add or train your own models in the "Models" file menu and choose model here'
-        self.ModelChooseC.setToolTip(tipstr)
-        self.ModelChooseC.activated.connect(lambda: self.model_choose(custom=True))
-        self.modelBoxG.addWidget(self.ModelChooseC, widget_row, 0, 1, 8)
-
-        # compute segmentation w/ custom model
-        self.ModelButtonC = QPushButton(u"run")
-        self.ModelButtonC.setFont(self.medfont)
-        self.ModelButtonC.setFixedWidth(35)
-        self.ModelButtonC.clicked.connect(
-            lambda: self.compute_segmentation(custom=True))
-        self.modelBoxG.addWidget(self.ModelButtonC, widget_row, 8, 1, 1)
-        self.ModelButtonC.setEnabled(False)
-
-
-        b += 1
-        self.filterBox = QGroupBox("Image filtering")
-        self.filterBox.setFont(self.boldfont)
-        self.filterBox_grid_layout = QGridLayout()
-        self.filterBox.setLayout(self.filterBox_grid_layout)
-        self.l0.addWidget(self.filterBox, b, 0, 1, 9)
-
-        widget_row = 0
-        
-        # Filtering
-        self.FilterButtons = []
-        nett = [
-            "clear restore/filter",
-            "filter image (settings below)",
-        ]
-        self.filter_text = ["none", 
-                             "filter", 
-                             ]
-        self.restore = None
-        self.ratio = 1.
-        jj = 0
-        w = 3
-        for j in range(len(self.filter_text)):
-            self.FilterButtons.append(
-                guiparts.FilterButton(self, self.filter_text[j]))
-            self.filterBox_grid_layout.addWidget(self.FilterButtons[-1], widget_row, jj, 1, w)
-            self.FilterButtons[-1].setFixedWidth(75)
-            self.FilterButtons[-1].setToolTip(nett[j])
-            self.FilterButtons[-1].setFont(self.medfont)
-            widget_row += 1 if j%2==1 else 0
-            jj = 0 if j%2==1 else jj + w
-
-        self.save_norm = QCheckBox("save restored/filtered image")
-        self.save_norm.setFont(self.medfont)
-        self.save_norm.setToolTip("save restored/filtered image in _seg.npy file")
-        self.save_norm.setChecked(True)
-
-        widget_row += 2
-
-        self.filtBox = QCollapsible("custom filter settings")
-        self.filtBox._toggle_btn.setFont(self.medfont)
-        self.filtBoxG = QGridLayout()
-        _content = QWidget()
-        _content.setLayout(self.filtBoxG)
-        _content.setMaximumHeight(0)
-        _content.setMinimumHeight(0)
-        self.filtBox.setContent(_content)
-        self.filterBox_grid_layout.addWidget(self.filtBox, widget_row, 0, 1, 9)
-
-        self.filt_vals = [0., 0., 0., 0.]
-        self.filt_edits = []
-        labels = [
-            "sharpen\nradius", "smooth\nradius", "tile_norm\nblocksize",
-            "tile_norm\nsmooth3D"
-        ]
-        tooltips = [
-            "set size of surround-subtraction filter for sharpening image",
-            "set size of gaussian filter for smoothing image",
-            "set size of tiles to use to normalize image",
-            "set amount of smoothing of normalization values across planes"
-        ]
-
-        for p in range(4):
-            label = QLabel(f"{labels[p]}:")
-            label.setToolTip(tooltips[p])
-            label.setFont(self.medfont)
-            self.filtBoxG.addWidget(label, widget_row + p // 2, 4 * (p % 2), 1, 2)
-            self.filt_edits.append(QLineEdit())
-            self.filt_edits[p].setText(str(self.filt_vals[p]))
-            self.filt_edits[p].setFixedWidth(40)
-            self.filt_edits[p].setFont(self.medfont)
-            self.filtBoxG.addWidget(self.filt_edits[p], widget_row + p // 2, 4 * (p % 2) + 2, 1,
-                                    2)
-            self.filt_edits[p].setToolTip(tooltips[p])
-
-        widget_row += 3
-        self.norm3D_cb = QCheckBox("norm3D")
-        self.norm3D_cb.setFont(self.medfont)
-        self.norm3D_cb.setChecked(True)
-        self.norm3D_cb.setToolTip("run same normalization across planes")
-        self.filtBoxG.addWidget(self.norm3D_cb, widget_row, 0, 1, 3)
-
-
-        return b
-
-    def level_change(self, r):
-        r = ["red", "green", "blue"].index(r)
-        if self.loaded:
-            sval = self.sliders[r].value()
-            self.saturation[r][self.currentZ] = sval
-            if not self.autobtn.isChecked():
-                for r in range(3):
-                    for i in range(len(self.saturation[r])):
-                        self.saturation[r][i] = self.saturation[r][self.currentZ]
-            self.update_plot()
-
-    def keyPressEvent(self, event):
-        if self.loaded:
-            if not (event.modifiers() &
-                    (QtCore.Qt.ControlModifier | QtCore.Qt.ShiftModifier |
-                     QtCore.Qt.AltModifier) or self.in_stroke):
-                updated = False
-                if len(self.current_point_set) > 0:
-                    if event.key() == QtCore.Qt.Key_Return:
-                        self.add_set()
-                else:
-                    nviews = self.ViewDropDown.count() - 1
-                    nviews += int(
-                        self.ViewDropDown.model().item(self.ViewDropDown.count() -
-                                                       1).isEnabled())
-                    if event.key() == QtCore.Qt.Key_X:
-                        self.MCheckBox.toggle()
-                    if event.key() == QtCore.Qt.Key_Z:
-                        self.OCheckBox.toggle()
-                    if event.key() == QtCore.Qt.Key_Left or event.key(
-                    ) == QtCore.Qt.Key_A:
-                        self.get_prev_image()
-                    elif event.key() == QtCore.Qt.Key_Right or event.key(
-                    ) == QtCore.Qt.Key_D:
-                        self.get_next_image()
-                    elif event.key() == QtCore.Qt.Key_PageDown:
-                        self.view = (self.view + 1) % (nviews)
-                        self.ViewDropDown.setCurrentIndex(self.view)
-                    elif event.key() == QtCore.Qt.Key_PageUp:
-                        self.view = (self.view - 1) % (nviews)
-                        self.ViewDropDown.setCurrentIndex(self.view)
-
-                # can change background or stroke size if cell not finished
-                if event.key() == QtCore.Qt.Key_Up or event.key() == QtCore.Qt.Key_W:
-                    self.color = (self.color - 1) % (6)
-                    self.RGBDropDown.setCurrentIndex(self.color)
-                elif event.key() == QtCore.Qt.Key_Down or event.key(
-                ) == QtCore.Qt.Key_S:
-                    self.color = (self.color + 1) % (6)
-                    self.RGBDropDown.setCurrentIndex(self.color)
-                elif event.key() == QtCore.Qt.Key_R:
-                    if self.color != 1:
-                        self.color = 1
-                    else:
-                        self.color = 0
-                    self.RGBDropDown.setCurrentIndex(self.color)
-                elif event.key() == QtCore.Qt.Key_G:
-                    if self.color != 2:
-                        self.color = 2
-                    else:
-                        self.color = 0
-                    self.RGBDropDown.setCurrentIndex(self.color)
-                elif event.key() == QtCore.Qt.Key_B:
-                    if self.color != 3:
-                        self.color = 3
-                    else:
-                        self.color = 0
-                    self.RGBDropDown.setCurrentIndex(self.color)
-                elif (event.key() == QtCore.Qt.Key_Comma or
-                      event.key() == QtCore.Qt.Key_Period):
-                    count = self.BrushChoose.count()
-                    gci = self.BrushChoose.currentIndex()
-                    if event.key() == QtCore.Qt.Key_Comma:
-                        gci = max(0, gci - 1)
-                    else:
-                        gci = min(count - 1, gci + 1)
-                    self.BrushChoose.setCurrentIndex(gci)
-                    self.brush_choose()
-                if not updated:
-                    self.update_plot()
-        if event.key() == QtCore.Qt.Key_Minus or event.key() == QtCore.Qt.Key_Equal:
-            self.p0.keyPressEvent(event)
-
-    def autosave_on(self):
-        if self.SCheckBox.isChecked():
-            self.autosave = True
-        else:
-            self.autosave = False
-
-    def check_gpu(self, torch=True):
-        # also decide whether or not to use torch
-        self.useGPU.setChecked(False)
-        self.useGPU.setEnabled(False)
-        if core.use_gpu(use_torch=True):
-            self.useGPU.setEnabled(True)
-            self.useGPU.setChecked(True)
-        else:
-            self.useGPU.setStyleSheet("color: rgb(80,80,80);")
-
-
-    def model_choose(self, custom=False):
-        index = self.ModelChooseC.currentIndex(
-        ) if custom else self.ModelChooseB.currentIndex()
-        if index > 0:
-            if custom:
-                model_name = self.ModelChooseC.currentText()
-            else:
-                model_name = self.net_names[index - 1]
-            print(f"GUI_INFO: selected model {model_name}, loading now")
-            self.initialize_model(model_name=model_name, custom=custom)
-
-    def toggle_scale(self):
-        if self.scale_on:
-            self.p0.removeItem(self.scale)
-            self.scale_on = False
-        else:
-            self.p0.addItem(self.scale)
-            self.scale_on = True
-
-    def enable_buttons(self):
-        if len(self.model_strings) > 0:
-            self.ModelButtonC.setEnabled(True)
-        for i in range(len(self.StyleButtons)):
-            self.StyleButtons[i].setEnabled(True)
-
-        for i in range(len(self.FilterButtons)):
-            self.FilterButtons[i].setEnabled(True)
-        if self.load_3D:
-            self.FilterButtons[-2].setEnabled(False)
-
-        self.newmodel.setEnabled(True)
-        self.loadMasks.setEnabled(True)
-
-        for n in range(self.nchan):
-            self.sliders[n].setEnabled(True)
-        for n in range(self.nchan, 3):
-            self.sliders[n].setEnabled(True)
-
-        self.toggle_mask_ops()
-
-        self.update_plot()
-        self.setWindowTitle(self.filename)
-
-    def disable_buttons_removeROIs(self):
-        if len(self.model_strings) > 0:
-            self.ModelButtonC.setEnabled(False)
-        for i in range(len(self.StyleButtons)):
-            self.StyleButtons[i].setEnabled(False)
-        self.newmodel.setEnabled(False)
-        self.loadMasks.setEnabled(False)
-        self.saveSet.setEnabled(False)
-        self.savePNG.setEnabled(False)
-        self.saveFlows.setEnabled(False)
-        self.saveOutlines.setEnabled(False)
-        self.saveROIs.setEnabled(False)
-
-        self.MakeDeletionRegionButton.setEnabled(False)
-        self.DeleteMultipleROIButton.setEnabled(False)
-        self.DoneDeleteMultipleROIButton.setEnabled(True)
-        self.CancelDeleteMultipleROIButton.setEnabled(True)
-
-    def toggle_mask_ops(self):
-        self.update_layer()
-        self.toggle_saving()
-        self.toggle_removals()
-
-    def toggle_saving(self):
-        if self.ncells > 0:
-            self.saveSet.setEnabled(True)
-            self.savePNG.setEnabled(True)
-            self.saveFlows.setEnabled(True)
-            self.saveOutlines.setEnabled(True)
-            self.saveROIs.setEnabled(True)
-        else:
-            self.saveSet.setEnabled(False)
-            self.savePNG.setEnabled(False)
-            self.saveFlows.setEnabled(False)
-            self.saveOutlines.setEnabled(False)
-            self.saveROIs.setEnabled(False)
-
-    def toggle_removals(self):
-        if self.ncells > 0:
-            self.ClearButton.setEnabled(True)
-            self.remcell.setEnabled(True)
-            self.undo.setEnabled(True)
-            self.MakeDeletionRegionButton.setEnabled(True)
-            self.DeleteMultipleROIButton.setEnabled(True)
-            self.DoneDeleteMultipleROIButton.setEnabled(False)
-            self.CancelDeleteMultipleROIButton.setEnabled(False)
-        else:
-            self.ClearButton.setEnabled(False)
-            self.remcell.setEnabled(False)
-            self.undo.setEnabled(False)
-            self.MakeDeletionRegionButton.setEnabled(False)
-            self.DeleteMultipleROIButton.setEnabled(False)
-            self.DoneDeleteMultipleROIButton.setEnabled(False)
-            self.CancelDeleteMultipleROIButton.setEnabled(False)
-
-    def remove_action(self):
-        if self.selected > 0:
-            self.remove_cell(self.selected)
-
-    def undo_action(self):
-        if (len(self.strokes) > 0 and self.strokes[-1][0][0] == self.currentZ):
-            self.remove_stroke()
-        else:
-            # remove previous cell
-            if self.ncells > 0:
-                self.remove_cell(self.ncells.get())
-
-    def undo_remove_action(self):
-        self.undo_remove_cell()
-
-    def get_files(self):
-        folder = os.path.dirname(self.filename)
-        mask_filter = "_masks"
-        images = get_image_files(folder, mask_filter)
-        fnames = [os.path.split(images[k])[-1] for k in range(len(images))]
-        f0 = os.path.split(self.filename)[-1]
-        idx = np.nonzero(np.array(fnames) == f0)[0][0]
-        return images, idx
-
-    def get_prev_image(self):
-        images, idx = self.get_files()
-        idx = (idx - 1) % len(images)
-        io._load_image(self, filename=images[idx])
-
-    def get_next_image(self, load_seg=True):
-        images, idx = self.get_files()
-        idx = (idx + 1) % len(images)
-        io._load_image(self, filename=images[idx], load_seg=load_seg)
-
-    def dragEnterEvent(self, event):
-        if event.mimeData().hasUrls():
-            event.accept()
-        else:
-            event.ignore()
-
-    def dropEvent(self, event):
-        files = [u.toLocalFile() for u in event.mimeData().urls()]
-        if os.path.splitext(files[0])[-1] == ".npy":
-            io._load_seg(self, filename=files[0], load_3D=self.load_3D)
-        else:
-            io._load_image(self, filename=files[0], load_seg=True, load_3D=self.load_3D)
-
-    def toggle_masks(self):
-        if self.MCheckBox.isChecked():
-            self.masksOn = True
-        else:
-            self.masksOn = False
-        if self.OCheckBox.isChecked():
-            self.outlinesOn = True
-        else:
-            self.outlinesOn = False
-        if not self.masksOn and not self.outlinesOn:
-            self.p0.removeItem(self.layer)
-            self.layer_off = True
-        else:
-            if self.layer_off:
-                self.p0.addItem(self.layer)
-            self.draw_layer()
-            self.update_layer()
-        if self.loaded:
-            self.update_plot()
-            self.update_layer()
-
-    def make_viewbox(self):
-        self.p0 = guiparts.ViewBoxNoRightDrag(parent=self, lockAspect=True,
-                                              name="plot1", border=[100, 100,
-                                                                    100], invertY=True)
-        self.p0.setCursor(QtCore.Qt.CrossCursor)
-        self.brush_size = 3
-        self.win.addItem(self.p0, 0, 0, rowspan=1, colspan=1)
-        self.p0.setMenuEnabled(False)
-        self.p0.setMouseEnabled(x=True, y=True)
-        self.img = pg.ImageItem(viewbox=self.p0, parent=self)
-        self.img.autoDownsample = False
-        self.layer = guiparts.ImageDraw(viewbox=self.p0, parent=self)
-        self.layer.setLevels([0, 255])
-        self.scale = pg.ImageItem(viewbox=self.p0, parent=self)
-        self.scale.setLevels([0, 255])
-        self.p0.scene().contextMenuItem = self.p0
-        self.Ly, self.Lx = 512, 512
-        self.p0.addItem(self.img)
-        self.p0.addItem(self.layer)
-        self.p0.addItem(self.scale)
-
-    def reset(self):
-        # ---- start sets of points ---- #
-        self.selected = 0
-        self.nchan = 3
-        self.loaded = False
-        self.channel = [0, 1]
-        self.current_point_set = []
-        self.in_stroke = False
-        self.strokes = []
-        self.stroke_appended = True
-        self.resize = False
-        self.ncells.reset()
-        self.zdraw = []
-        self.removed_cell = []
-        self.cellcolors = np.array([255, 255, 255])[np.newaxis, :]
-
-        # -- zero out image stack -- #
-        self.opacity = 128  # how opaque masks should be
-        self.outcolor = [200, 200, 255, 200]
-        self.NZ, self.Ly, self.Lx = 1, 256, 256
-        self.saturation = self.saturation if hasattr(self, 'saturation') else []
-
-        # only adjust the saturation if auto-adjust is on: 
-        if self.autobtn.isChecked():
-            for r in range(3):
-                self.saturation.append([[0, 255] for n in range(self.NZ)])
-                self.sliders[r].setValue([0, 255])
-                self.sliders[r].setEnabled(False)
-                self.sliders[r].show()
-        self.currentZ = 0
-        self.flows = [[], [], [], [], [[]]]
-        # masks matrix
-        # image matrix with a scale disk
-        self.stack = np.zeros((1, self.Ly, self.Lx, 3))
-        self.Lyr, self.Lxr = self.Ly, self.Lx
-        self.Ly0, self.Lx0 = self.Ly, self.Lx
-        self.radii = 0 * np.ones((self.Ly, self.Lx, 4), np.uint8)
-        self.layerz = 0 * np.ones((self.Ly, self.Lx, 4), np.uint8)
-        self.cellpix = np.zeros((1, self.Ly, self.Lx), np.uint16)
-        self.outpix = np.zeros((1, self.Ly, self.Lx), np.uint16)
-        self.ismanual = np.zeros(0, "bool")
-
-        # -- set menus to default -- #
-        self.color = 0
-        self.RGBDropDown.setCurrentIndex(self.color)
-        self.view = 0
-        self.ViewDropDown.setCurrentIndex(0)
-        self.ViewDropDown.model().item(self.ViewDropDown.count() - 1).setEnabled(False)
-        self.delete_restore()
-
-        self.clear_all()
-
-        self.filename = []
-        self.loaded = False
-        self.recompute_masks = False
-
-        self.deleting_multiple = False
-        self.removing_cells_list = []
-        self.removing_region = False
-        self.remove_roi_obj = None
-
-    def delete_restore(self):
-        """ delete restored imgs but don't reset settings """
-        if hasattr(self, "stack_filtered"):
-            del self.stack_filtered
-        if hasattr(self, "cellpix_orig"):
-            self.cellpix = self.cellpix_orig.copy()
-            self.outpix = self.outpix_orig.copy()
-            del self.outpix_orig, self.outpix_resize
-            del self.cellpix_orig, self.cellpix_resize
-
-    def clear_restore(self):
-        """ delete restored imgs and reset settings """
-        print("GUI_INFO: clearing restored image")
-        self.ViewDropDown.model().item(self.ViewDropDown.count() - 1).setEnabled(False)
-        if self.ViewDropDown.currentIndex() == self.ViewDropDown.count() - 1:
-            self.ViewDropDown.setCurrentIndex(0)
-        self.delete_restore()
-        self.restore = None
-        self.ratio = 1.
-        self.set_normalize_params(self.get_normalize_params())
-
-    def brush_choose(self):
-        self.brush_size = self.BrushChoose.currentIndex() * 2 + 1
-        if self.loaded:
-            self.layer.setDrawKernel(kernel_size=self.brush_size)
-            self.update_layer()
-
-    def clear_all(self):
-        self.prev_selected = 0
-        self.selected = 0
-        if self.restore and "upsample" in self.restore:
-            self.layerz = 0 * np.ones((self.Lyr, self.Lxr, 4), np.uint8)
-            self.cellpix = np.zeros((self.NZ, self.Lyr, self.Lxr), np.uint16)
-            self.outpix = np.zeros((self.NZ, self.Lyr, self.Lxr), np.uint16)
-            self.cellpix_resize = self.cellpix.copy()
-            self.outpix_resize = self.outpix.copy()
-            self.cellpix_orig = np.zeros((self.NZ, self.Ly0, self.Lx0), np.uint16)
-            self.outpix_orig = np.zeros((self.NZ, self.Ly0, self.Lx0), np.uint16)
-        else:
-            self.layerz = 0 * np.ones((self.Ly, self.Lx, 4), np.uint8)
-            self.cellpix = np.zeros((self.NZ, self.Ly, self.Lx), np.uint16)
-            self.outpix = np.zeros((self.NZ, self.Ly, self.Lx), np.uint16)
-
-        self.cellcolors = np.array([255, 255, 255])[np.newaxis, :]
-        self.ncells.reset()
-        self.toggle_removals()
-        self.update_scale()
-        self.update_layer()
-
-    def select_cell(self, idx):
-        self.prev_selected = self.selected
-        self.selected = idx
-        if self.selected > 0:
-            z = self.currentZ
-            self.layerz[self.cellpix[z] == idx] = np.array(
-                [255, 255, 255, self.opacity])
-            self.update_layer()
-
-    def select_cell_multi(self, idx):
-        if idx > 0:
-            z = self.currentZ
-            self.layerz[self.cellpix[z] == idx] = np.array(
-                [255, 255, 255, self.opacity])
-            self.update_layer()
-
-    def unselect_cell(self):
-        if self.selected > 0:
-            idx = self.selected
-            if idx < (self.ncells.get() + 1):
-                z = self.currentZ
-                self.layerz[self.cellpix[z] == idx] = np.append(
-                    self.cellcolors[idx], self.opacity)
-                if self.outlinesOn:
-                    self.layerz[self.outpix[z] == idx] = np.array(self.outcolor).astype(
-                        np.uint8)
-                    #[0,0,0,self.opacity])
-                self.update_layer()
-        self.selected = 0
-
-    def unselect_cell_multi(self, idx):
-        z = self.currentZ
-        self.layerz[self.cellpix[z] == idx] = np.append(self.cellcolors[idx],
-                                                        self.opacity)
-        if self.outlinesOn:
-            self.layerz[self.outpix[z] == idx] = np.array(self.outcolor).astype(
-                np.uint8)
-            # [0,0,0,self.opacity])
-        self.update_layer()
-
-    def remove_cell(self, idx):
-        if isinstance(idx, (int, np.integer)):
-            idx = [idx]
-        # because the function remove_single_cell updates the state of the cellpix and outpix arrays
-        # by reindexing cells to avoid gaps in the indices, we need to remove the cells in reverse order
-        # so that the indices are correct
-        idx.sort(reverse=True)
-        for i in idx:
-            self.remove_single_cell(i)
-        self.ncells -= len(idx)  # _save_sets uses ncells
-        self.update_layer()
-
-        if self.ncells == 0:
-            self.ClearButton.setEnabled(False)
-        if self.NZ == 1:
-            io._save_sets_with_check(self)
-
-
-    def remove_single_cell(self, idx):
-        # remove from manual array
-        self.selected = 0
-        if self.NZ > 1:
-            zextent = ((self.cellpix == idx).sum(axis=(1, 2)) > 0).nonzero()[0]
-        else:
-            zextent = [0]
-        for z in zextent:
-            cp = self.cellpix[z] == idx
-            op = self.outpix[z] == idx
-            # remove from self.cellpix and self.outpix
-            self.cellpix[z, cp] = 0
-            self.outpix[z, op] = 0
-            if z == self.currentZ:
-                # remove from mask layer
-                self.layerz[cp] = np.array([0, 0, 0, 0])
-
-        # reduce other pixels by -1
-        self.cellpix[self.cellpix > idx] -= 1
-        self.outpix[self.outpix > idx] -= 1
-
-        if self.NZ == 1:
-            self.removed_cell = [
-                self.ismanual[idx - 1], self.cellcolors[idx],
-                np.nonzero(cp),
-                np.nonzero(op)
-            ]
-            self.redo.setEnabled(True)
-            ar, ac = self.removed_cell[2]
-            d = datetime.datetime.now()
-            self.track_changes.append(
-                [d.strftime("%m/%d/%Y, %H:%M:%S"), "removed mask", [ar, ac]])
-        # remove cell from lists
-        self.ismanual = np.delete(self.ismanual, idx - 1)
-        self.cellcolors = np.delete(self.cellcolors, [idx], axis=0)
-        del self.zdraw[idx - 1]
-        print("GUI_INFO: removed cell %d" % (idx - 1))
-
-    def remove_region_cells(self):
-        if self.removing_cells_list:
-            for idx in self.removing_cells_list:
-                self.unselect_cell_multi(idx)
-            self.removing_cells_list.clear()
-        self.disable_buttons_removeROIs()
-        self.removing_region = True
-
-        self.clear_multi_selected_cells()
-
-        # make roi region here in center of view, making ROI half the size of the view
-        roi_width = self.p0.viewRect().width() / 2
-        x_loc = self.p0.viewRect().x() + (roi_width / 2)
-        roi_height = self.p0.viewRect().height() / 2
-        y_loc = self.p0.viewRect().y() + (roi_height / 2)
-
-        pos = [x_loc, y_loc]
-        roi = pg.RectROI(pos, [roi_width, roi_height], pen=pg.mkPen("y", width=2),
-                         removable=True)
-        roi.sigRemoveRequested.connect(self.remove_roi)
-        roi.sigRegionChangeFinished.connect(self.roi_changed)
-        self.p0.addItem(roi)
-        self.remove_roi_obj = roi
-        self.roi_changed(roi)
-
-    def delete_multiple_cells(self):
-        self.unselect_cell()
-        self.disable_buttons_removeROIs()
-        self.DoneDeleteMultipleROIButton.setEnabled(True)
-        self.MakeDeletionRegionButton.setEnabled(True)
-        self.CancelDeleteMultipleROIButton.setEnabled(True)
-        self.deleting_multiple = True
-
-    def done_remove_multiple_cells(self):
-        self.deleting_multiple = False
-        self.removing_region = False
-        self.DoneDeleteMultipleROIButton.setEnabled(False)
-        self.MakeDeletionRegionButton.setEnabled(False)
-        self.CancelDeleteMultipleROIButton.setEnabled(False)
-
-        if self.removing_cells_list:
-            self.removing_cells_list = list(set(self.removing_cells_list))
-            display_remove_list = [i - 1 for i in self.removing_cells_list]
-            print(f"GUI_INFO: removing cells: {display_remove_list}")
-            self.remove_cell(self.removing_cells_list)
-            self.removing_cells_list.clear()
-            self.unselect_cell()
-        self.enable_buttons()
-
-        if self.remove_roi_obj is not None:
-            self.remove_roi(self.remove_roi_obj)
-
-    def merge_cells(self, idx):
-        self.prev_selected = self.selected
-        self.selected = idx
-        if self.selected != self.prev_selected:
-            for z in range(self.NZ):
-                ar0, ac0 = np.nonzero(self.cellpix[z] == self.prev_selected)
-                ar1, ac1 = np.nonzero(self.cellpix[z] == self.selected)
-                touching = np.logical_and((ar0[:, np.newaxis] - ar1) < 3,
-                                          (ac0[:, np.newaxis] - ac1) < 3).sum()
-                ar = np.hstack((ar0, ar1))
-                ac = np.hstack((ac0, ac1))
-                vr0, vc0 = np.nonzero(self.outpix[z] == self.prev_selected)
-                vr1, vc1 = np.nonzero(self.outpix[z] == self.selected)
-                self.outpix[z, vr0, vc0] = 0
-                self.outpix[z, vr1, vc1] = 0
-                if touching > 0:
-                    mask = np.zeros((np.ptp(ar) + 4, np.ptp(ac) + 4), np.uint8)
-                    mask[ar - ar.min() + 2, ac - ac.min() + 2] = 1
-                    contours = cv2.findContours(mask, cv2.RETR_EXTERNAL,
-                                                cv2.CHAIN_APPROX_NONE)
-                    pvc, pvr = contours[-2][0].squeeze().T
-                    vr, vc = pvr + ar.min() - 2, pvc + ac.min() - 2
-
-                else:
-                    vr = np.hstack((vr0, vr1))
-                    vc = np.hstack((vc0, vc1))
-                color = self.cellcolors[self.prev_selected]
-                self.draw_mask(z, ar, ac, vr, vc, color, idx=self.prev_selected)
-            self.remove_cell(self.selected)
-            print("GUI_INFO: merged two cells")
-            self.update_layer()
-            io._save_sets_with_check(self)
-            self.undo.setEnabled(False)
-            self.redo.setEnabled(False)
-
-    def undo_remove_cell(self):
-        if len(self.removed_cell) > 0:
-            z = 0
-            ar, ac = self.removed_cell[2]
-            vr, vc = self.removed_cell[3]
-            color = self.removed_cell[1]
-            self.draw_mask(z, ar, ac, vr, vc, color)
-            self.toggle_mask_ops()
-            self.cellcolors = np.append(self.cellcolors, color[np.newaxis, :], axis=0)
-            self.ncells += 1
-            self.ismanual = np.append(self.ismanual, self.removed_cell[0])
-            self.zdraw.append([])
-            print(">>> added back removed cell")
-            self.update_layer()
-            io._save_sets_with_check(self)
-            self.removed_cell = []
-            self.redo.setEnabled(False)
-
-    def remove_stroke(self, delete_points=True, stroke_ind=-1):
-        stroke = np.array(self.strokes[stroke_ind])
-        cZ = self.currentZ
-        inZ = stroke[0, 0] == cZ
-        if inZ:
-            outpix = self.outpix[cZ, stroke[:, 1], stroke[:, 2]] > 0
-            self.layerz[stroke[~outpix, 1], stroke[~outpix, 2]] = np.array([0, 0, 0, 0])
-            cellpix = self.cellpix[cZ, stroke[:, 1], stroke[:, 2]]
-            ccol = self.cellcolors.copy()
-            if self.selected > 0:
-                ccol[self.selected] = np.array([255, 255, 255])
-            col2mask = ccol[cellpix]
-            if self.masksOn:
-                col2mask = np.concatenate(
-                    (col2mask, self.opacity * (cellpix[:, np.newaxis] > 0)), axis=-1)
-            else:
-                col2mask = np.concatenate((col2mask, 0 * (cellpix[:, np.newaxis] > 0)),
-                                          axis=-1)
-            self.layerz[stroke[:, 1], stroke[:, 2], :] = col2mask
-            if self.outlinesOn:
-                self.layerz[stroke[outpix, 1], stroke[outpix,
-                                                      2]] = np.array(self.outcolor)
-            if delete_points:
-                del self.current_point_set[stroke_ind]
-            self.update_layer()
-
-        del self.strokes[stroke_ind]
-
-    def plot_clicked(self, event):
-        if event.button()==QtCore.Qt.LeftButton \
-                and not event.modifiers() & (QtCore.Qt.ShiftModifier | QtCore.Qt.AltModifier)\
-                and not self.removing_region:
-            if event.double():
-                try:
-                    self.p0.setYRange(0, self.Ly + self.pr)
-                except:
-                    self.p0.setYRange(0, self.Ly)
-                self.p0.setXRange(0, self.Lx)
-
-    def cancel_remove_multiple(self):
-        self.clear_multi_selected_cells()
-        self.done_remove_multiple_cells()
-
-    def clear_multi_selected_cells(self):
-        # unselect all previously selected cells:
-        for idx in self.removing_cells_list:
-            self.unselect_cell_multi(idx)
-        self.removing_cells_list.clear()
-
-    def add_roi(self, roi):
-        self.p0.addItem(roi)
-        self.remove_roi_obj = roi
-
-    def remove_roi(self, roi):
-        self.clear_multi_selected_cells()
-        assert roi == self.remove_roi_obj
-        self.remove_roi_obj = None
-        self.p0.removeItem(roi)
-        self.removing_region = False
-
-    def roi_changed(self, roi):
-        # find the overlapping cells and make them selected
-        pos = roi.pos()
-        size = roi.size()
-        x0 = int(pos.x())
-        y0 = int(pos.y())
-        x1 = int(pos.x() + size.x())
-        y1 = int(pos.y() + size.y())
-        if x0 < 0:
-            x0 = 0
-        if y0 < 0:
-            y0 = 0
-        if x1 > self.Lx:
-            x1 = self.Lx
-        if y1 > self.Ly:
-            y1 = self.Ly
-
-        # find cells in that region
-        cell_idxs = np.unique(self.cellpix[self.currentZ, y0:y1, x0:x1])
-        cell_idxs = np.trim_zeros(cell_idxs)
-        # deselect cells not in region by deselecting all and then selecting the ones in the region
-        self.clear_multi_selected_cells()
-
-        for idx in cell_idxs:
-            self.select_cell_multi(idx)
-            self.removing_cells_list.append(idx)
-
-        self.update_layer()
-
-    def mouse_moved(self, pos):
-        items = self.win.scene().items(pos)
-
-    def color_choose(self):
-        self.color = self.RGBDropDown.currentIndex()
-        self.view = 0
-        self.ViewDropDown.setCurrentIndex(self.view)
-        self.update_plot()
-
-    def update_plot(self):
-        self.view = self.ViewDropDown.currentIndex()
-        self.Ly, self.Lx, _ = self.stack[self.currentZ].shape
-
-        if self.view == 0 or self.view == self.ViewDropDown.count() - 1:
-            image = self.stack[
-                self.currentZ] if self.view == 0 else self.stack_filtered[self.currentZ]
-            if self.color == 0:
-                self.img.setImage(image, autoLevels=False, lut=None)
-                if self.nchan > 1:
-                    levels = np.array([
-                        self.saturation[0][self.currentZ],
-                        self.saturation[1][self.currentZ],
-                        self.saturation[2][self.currentZ]
-                    ])
-                    self.img.setLevels(levels)
-                else:
-                    self.img.setLevels(self.saturation[0][self.currentZ])
-            elif self.color > 0 and self.color < 4:
-                if self.nchan > 1:
-                    image = image[:, :, self.color - 1]
-                self.img.setImage(image, autoLevels=False, lut=self.cmap[self.color])
-                if self.nchan > 1:
-                    self.img.setLevels(self.saturation[self.color - 1][self.currentZ])
-                else:
-                    self.img.setLevels(self.saturation[0][self.currentZ])
-            elif self.color == 4:
-                if self.nchan > 1:
-                    image = image.mean(axis=-1)
-                self.img.setImage(image, autoLevels=False, lut=None)
-                self.img.setLevels(self.saturation[0][self.currentZ])
-            elif self.color == 5:
-                if self.nchan > 1:
-                    image = image.mean(axis=-1)
-                self.img.setImage(image, autoLevels=False, lut=self.cmap[0])
-                self.img.setLevels(self.saturation[0][self.currentZ])
-        else:
-            image = np.zeros((self.Ly, self.Lx), np.uint8)
-            if len(self.flows) >= self.view - 1 and len(self.flows[self.view - 1]) > 0:
-                image = self.flows[self.view - 1][self.currentZ]
-            if self.view > 1:
-                self.img.setImage(image, autoLevels=False, lut=self.bwr)
-            else:
-                self.img.setImage(image, autoLevels=False, lut=None)
-            self.img.setLevels([0.0, 255.0])
-
-        for r in range(3):
-            self.sliders[r].setValue([
-                self.saturation[r][self.currentZ][0],
-                self.saturation[r][self.currentZ][1]
-            ])
-        self.win.show()
-        self.show()
-
-
-    def update_layer(self):
-        if self.masksOn or self.outlinesOn:
-            self.layer.setImage(self.layerz, autoLevels=False)
-        self.win.show()
-        self.show()
-
-
-    def add_set(self):
-        if len(self.current_point_set) > 0:
-            while len(self.strokes) > 0:
-                self.remove_stroke(delete_points=False)
-            if len(self.current_point_set[0]) > 8:
-                color = self.colormap[self.ncells.get(), :3]
-                median = self.add_mask(points=self.current_point_set, color=color)
-                if median is not None:
-                    self.removed_cell = []
-                    self.toggle_mask_ops()
-                    self.cellcolors = np.append(self.cellcolors, color[np.newaxis, :],
-                                                axis=0)
-                    self.ncells += 1
-                    self.ismanual = np.append(self.ismanual, True)
-                    if self.NZ == 1:
-                        # only save after each cell if single image
-                        io._save_sets_with_check(self)
-            else:
-                print("GUI_ERROR: cell too small, not drawn")
-            self.current_stroke = []
-            self.strokes = []
-            self.current_point_set = []
-            self.update_layer()
-
-    def add_mask(self, points=None, color=(100, 200, 50), dense=True):
-        # points is list of strokes
-        points_all = np.concatenate(points, axis=0)
-        
-        # loop over z values
-        median = []
-        zdraw = np.unique(points_all[:, 0])
-        z = 0
-        ars, acs, vrs, vcs = np.zeros(0, "int"), np.zeros(0, "int"), np.zeros(
-            0, "int"), np.zeros(0, "int")
-        for stroke in points:
-            stroke = np.concatenate(stroke, axis=0).reshape(-1, 4)
-            vr = stroke[:, 1]
-            vc = stroke[:, 2]
-            # get points inside drawn points
-            mask = np.zeros((np.ptp(vr) + 4, np.ptp(vc) + 4), np.uint8)
-            pts = np.stack((vc - vc.min() + 2, vr - vr.min() + 2),
-                           axis=-1)[:, np.newaxis, :]
-            mask = cv2.fillPoly(mask, [pts], (255, 0, 0))
-            ar, ac = np.nonzero(mask)
-            ar, ac = ar + vr.min() - 2, ac + vc.min() - 2
-            # get dense outline
-            contours = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
-            pvc, pvr = contours[-2][0][:,0].T
-            vr, vc = pvr + vr.min() - 2, pvc + vc.min() - 2
-            # concatenate all points
-            ar, ac = np.hstack((np.vstack((vr, vc)), np.vstack((ar, ac))))
-            # if these pixels are overlapping with another cell, reassign them
-            ioverlap = self.cellpix[z][ar, ac] > 0
-            if (~ioverlap).sum() < 10:
-                print("GUI_ERROR: cell < 10 pixels without overlaps, not drawn")
-                return None
-            elif ioverlap.sum() > 0:
-                ar, ac = ar[~ioverlap], ac[~ioverlap]
-                # compute outline of new mask
-                mask = np.zeros((np.ptp(vr) + 4, np.ptp(vc) + 4), np.uint8)
-                mask[ar - vr.min() + 2, ac - vc.min() + 2] = 1
-                contours = cv2.findContours(mask, cv2.RETR_EXTERNAL,
-                                            cv2.CHAIN_APPROX_NONE)
-                pvc, pvr = contours[-2][0][:,0].T
-                vr, vc = pvr + vr.min() - 2, pvc + vc.min() - 2
-            ars = np.concatenate((ars, ar), axis=0)
-            acs = np.concatenate((acs, ac), axis=0)
-            vrs = np.concatenate((vrs, vr), axis=0)
-            vcs = np.concatenate((vcs, vc), axis=0)
-            
-        self.draw_mask(z, ars, acs, vrs, vcs, color)
-        median.append(np.array([np.median(ars), np.median(acs)]))
-
-        self.zdraw.append(zdraw)
-        d = datetime.datetime.now()
-        self.track_changes.append(
-            [d.strftime("%m/%d/%Y, %H:%M:%S"), "added mask", [ar, ac]])
-        return median
-
-    def draw_mask(self, z, ar, ac, vr, vc, color, idx=None):
-        """ draw single mask using outlines and area """
-        if idx is None:
-            idx = self.ncells + 1
-        self.cellpix[z, vr, vc] = idx
-        self.cellpix[z, ar, ac] = idx
-        self.outpix[z, vr, vc] = idx
-        if self.restore and "upsample" in self.restore:
-            if self.resize:
-                self.cellpix_resize[z, vr, vc] = idx
-                self.cellpix_resize[z, ar, ac] = idx
-                self.outpix_resize[z, vr, vc] = idx
-                self.cellpix_orig[z, (vr / self.ratio).astype(int),
-                                  (vc / self.ratio).astype(int)] = idx
-                self.cellpix_orig[z, (ar / self.ratio).astype(int),
-                                  (ac / self.ratio).astype(int)] = idx
-                self.outpix_orig[z, (vr / self.ratio).astype(int),
-                                 (vc / self.ratio).astype(int)] = idx
-            else:
-                self.cellpix_orig[z, vr, vc] = idx
-                self.cellpix_orig[z, ar, ac] = idx
-                self.outpix_orig[z, vr, vc] = idx
-
-                # get upsampled mask
-                vrr = (vr.copy() * self.ratio).astype(int)
-                vcr = (vc.copy() * self.ratio).astype(int)
-                mask = np.zeros((np.ptp(vrr) + 4, np.ptp(vcr) + 4), np.uint8)
-                pts = np.stack((vcr - vcr.min() + 2, vrr - vrr.min() + 2),
-                               axis=-1)[:, np.newaxis, :]
-                mask = cv2.fillPoly(mask, [pts], (255, 0, 0))
-                arr, acr = np.nonzero(mask)
-                arr, acr = arr + vrr.min() - 2, acr + vcr.min() - 2
-                # get dense outline
-                contours = cv2.findContours(mask, cv2.RETR_EXTERNAL,
-                                            cv2.CHAIN_APPROX_NONE)
-                pvc, pvr = contours[-2][0].squeeze().T
-                vrr, vcr = pvr + vrr.min() - 2, pvc + vcr.min() - 2
-                # concatenate all points
-                arr, acr = np.hstack((np.vstack((vrr, vcr)), np.vstack((arr, acr))))
-                self.cellpix_resize[z, vrr, vcr] = idx
-                self.cellpix_resize[z, arr, acr] = idx
-                self.outpix_resize[z, vrr, vcr] = idx
-
-        if z == self.currentZ:
-            self.layerz[ar, ac, :3] = color
-            if self.masksOn:
-                self.layerz[ar, ac, -1] = self.opacity
-            if self.outlinesOn:
-                self.layerz[vr, vc] = np.array(self.outcolor)
-
-    def compute_scale(self):
-        # get diameter from gui
-        diameter = self.segmentation_settings.diameter
-        if not diameter:
-            diameter = 30
-
-        self.pr = int(diameter)
-        self.radii_padding = int(self.pr * 1.25)
-        self.radii = np.zeros((self.Ly + self.radii_padding, self.Lx, 4), np.uint8)
-        yy, xx = disk([self.Ly + self.radii_padding / 2 - 1, self.pr / 2 + 1],
-                      self.pr / 2, self.Ly + self.radii_padding, self.Lx)
-        # rgb(150,50,150)
-        self.radii[yy, xx, 0] = 150
-        self.radii[yy, xx, 1] = 50
-        self.radii[yy, xx, 2] = 150
-        self.radii[yy, xx, 3] = 255
-        self.p0.setYRange(0, self.Ly + self.radii_padding)
-        self.p0.setXRange(0, self.Lx)
-
-    def update_scale(self):
-        self.compute_scale()
-        self.scale.setImage(self.radii, autoLevels=False)
-        self.scale.setLevels([0.0, 255.0])
-        self.win.show()
-        self.show()
-
-
-    def draw_layer(self):
-        if self.resize:
-            self.Ly, self.Lx = self.Lyr, self.Lxr
-        else:
-            self.Ly, self.Lx = self.Ly0, self.Lx0
-
-        if self.masksOn or self.outlinesOn:
-            if self.restore and "upsample" in self.restore:
-                if self.resize:
-                    self.cellpix = self.cellpix_resize.copy()
-                    self.outpix = self.outpix_resize.copy()
-                else:
-                    self.cellpix = self.cellpix_orig.copy()
-                    self.outpix = self.outpix_orig.copy()
-
-        self.layerz = np.zeros((self.Ly, self.Lx, 4), np.uint8)
-        if self.masksOn:
-            self.layerz[..., :3] = self.cellcolors[self.cellpix[self.currentZ], :]
-            self.layerz[..., 3] = self.opacity * (self.cellpix[self.currentZ]
-                                                  > 0).astype(np.uint8)
-            if self.selected > 0:
-                self.layerz[self.cellpix[self.currentZ] == self.selected] = np.array(
-                    [255, 255, 255, self.opacity])
-            cZ = self.currentZ
-            stroke_z = np.array([s[0][0] for s in self.strokes])
-            inZ = np.nonzero(stroke_z == cZ)[0]
-            if len(inZ) > 0:
-                for i in inZ:
-                    stroke = np.array(self.strokes[i])
-                    self.layerz[stroke[:, 1], stroke[:,
-                                                     2]] = np.array([255, 0, 255, 100])
-        else:
-            self.layerz[..., 3] = 0
-
-        if self.outlinesOn:
-            self.layerz[self.outpix[self.currentZ] > 0] = np.array(
-                self.outcolor).astype(np.uint8)
-
-
-    def set_normalize_params(self, normalize_params):
-        from cellpose.models import normalize_default
-        if self.restore != "filter":
-            keys = list(normalize_params.keys()).copy()
-            for key in keys:
-                if key != "percentile":
-                    normalize_params[key] = normalize_default[key]
-        normalize_params = {**normalize_default, **normalize_params}
-        out = self.check_filter_params(normalize_params["sharpen_radius"],
-                                       normalize_params["smooth_radius"],
-                                       normalize_params["tile_norm_blocksize"],
-                                       normalize_params["tile_norm_smooth3D"],
-                                       normalize_params["norm3D"],
-                                       normalize_params["invert"])
-
-
-    def check_filter_params(self, sharpen, smooth, tile_norm, smooth3D, norm3D, invert):
-        tile_norm = 0 if tile_norm < 0 else tile_norm
-        sharpen = 0 if sharpen < 0 else sharpen
-        smooth = 0 if smooth < 0 else smooth
-        smooth3D = 0 if smooth3D < 0 else smooth3D
-        norm3D = bool(norm3D)
-        invert = bool(invert)
-        if tile_norm > self.Ly and tile_norm > self.Lx:
-            print(
-                "GUI_ERROR: tile size (tile_norm) bigger than both image dimensions, disabling"
-            )
-            tile_norm = 0
-        self.filt_edits[0].setText(str(sharpen))
-        self.filt_edits[1].setText(str(smooth))
-        self.filt_edits[2].setText(str(tile_norm))
-        self.filt_edits[3].setText(str(smooth3D))
-        self.norm3D_cb.setChecked(norm3D)
-        return sharpen, smooth, tile_norm, smooth3D, norm3D, invert
-
-    def get_normalize_params(self):
-        percentile = [
-            self.segmentation_settings.low_percentile,
-            self.segmentation_settings.high_percentile,
-        ]
-        normalize_params = {"percentile": percentile}
-        norm3D = self.norm3D_cb.isChecked()
-        normalize_params["norm3D"] = norm3D
-        sharpen = float(self.filt_edits[0].text())
-        smooth = float(self.filt_edits[1].text())
-        tile_norm = float(self.filt_edits[2].text())
-        smooth3D = float(self.filt_edits[3].text())
-        invert = False
-        out = self.check_filter_params(sharpen, smooth, tile_norm, smooth3D, norm3D,
-                                        invert)
-        sharpen, smooth, tile_norm, smooth3D, norm3D, invert = out
-        normalize_params["sharpen_radius"] = sharpen
-        normalize_params["smooth_radius"] = smooth
-        normalize_params["tile_norm_blocksize"] = tile_norm
-        normalize_params["tile_norm_smooth3D"] = smooth3D
-        normalize_params["invert"] = invert
-
-        from cellpose.models import normalize_default
-        normalize_params = {**normalize_default, **normalize_params}
-
-        return normalize_params
-    
-    def compute_saturation_if_checked(self):
-        if self.autobtn.isChecked():
-            self.compute_saturation()
-
-    def compute_saturation(self, return_img=False):
-        norm = self.get_normalize_params()
-        print(norm)
-        sharpen, smooth = norm["sharpen_radius"], norm["smooth_radius"]
-        percentile = norm["percentile"]
-        tile_norm = norm["tile_norm_blocksize"]
-        invert = norm["invert"]
-        norm3D = norm["norm3D"]
-        smooth3D = norm["tile_norm_smooth3D"]
-        tile_norm = norm["tile_norm_blocksize"]
-
-        if sharpen > 0 or smooth > 0 or tile_norm > 0:
-            img_norm = self.stack.copy()
-        else:
-            img_norm = self.stack
-
-        if sharpen > 0 or smooth > 0 or tile_norm > 0:
-            self.restore = "filter"
-            print(
-                "GUI_INFO: computing filtered image because sharpen > 0 or tile_norm > 0"
-            )
-            print(
-                "GUI_WARNING: will use memory to create filtered image -- make sure to have RAM for this"
-            )
-            img_norm = self.stack.copy()
-            if sharpen > 0 or smooth > 0:
-                img_norm = smooth_sharpen_img(self.stack, sharpen_radius=sharpen,
-                                              smooth_radius=smooth)
-
-            if tile_norm > 0:
-                img_norm = normalize99_tile(img_norm, blocksize=tile_norm,
-                                            lower=percentile[0], upper=percentile[1],
-                                            smooth3D=smooth3D, norm3D=norm3D)
-            # convert to 0->255
-            img_norm_min = img_norm.min()
-            img_norm_max = img_norm.max()
-            for c in range(img_norm.shape[-1]):
-                if np.ptp(img_norm[..., c]) > 1e-3:
-                    img_norm[..., c] -= img_norm_min
-                    img_norm[..., c] /= (img_norm_max - img_norm_min)
-            img_norm *= 255
-            self.stack_filtered = img_norm
-            self.ViewDropDown.model().item(self.ViewDropDown.count() -
-                                           1).setEnabled(True)
-            self.ViewDropDown.setCurrentIndex(self.ViewDropDown.count() - 1)
-        else:
-            img_norm = self.stack if self.restore is None or self.restore == "filter" else self.stack_filtered
-
-        if self.autobtn.isChecked():
-            self.saturation = []
-            for c in range(img_norm.shape[-1]):
-                self.saturation.append([])
-                if np.ptp(img_norm[..., c]) > 1e-3:
-                    if norm3D:
-                        x01 = np.percentile(img_norm[..., c], percentile[0])
-                        x99 = np.percentile(img_norm[..., c], percentile[1])
-                        if invert:
-                            x01i = 255. - x99
-                            x99i = 255. - x01
-                            x01, x99 = x01i, x99i
-                        for n in range(self.NZ):
-                            self.saturation[-1].append([x01, x99])
-                    else:
-                        for z in range(self.NZ):
-                            if self.NZ > 1:
-                                x01 = np.percentile(img_norm[z, :, :, c], percentile[0])
-                                x99 = np.percentile(img_norm[z, :, :, c], percentile[1])
-                            else:
-                                x01 = np.percentile(img_norm[..., c], percentile[0])
-                                x99 = np.percentile(img_norm[..., c], percentile[1])
-                            if invert:
-                                x01i = 255. - x99
-                                x99i = 255. - x01
-                                x01, x99 = x01i, x99i
-                            self.saturation[-1].append([x01, x99])
-                else:
-                    for n in range(self.NZ):
-                        self.saturation[-1].append([0, 255.])
-            print(self.saturation[2][self.currentZ])
-
-            if img_norm.shape[-1] == 1:
-                self.saturation.append(self.saturation[0])
-                self.saturation.append(self.saturation[0])
-
-        # self.autobtn.setChecked(True)
-        self.update_plot()
-
-
-    def get_model_path(self, custom=False):
-        if custom:
-            self.current_model = self.ModelChooseC.currentText()
-            self.current_model_path = os.fspath(
-                models.MODEL_DIR.joinpath(self.current_model))
-        else:
-            self.current_model = "cpsam"
-            self.current_model_path = models.model_path(self.current_model)
-
-    def initialize_model(self, model_name=None, custom=False):
-        if model_name is None or custom:
-            self.get_model_path(custom=custom)
-            if not os.path.exists(self.current_model_path):
-                raise ValueError("need to specify model (use dropdown)")
-
-        if model_name is None or not isinstance(model_name, str):
-            self.model = models.CellposeModel(gpu=self.useGPU.isChecked(),
-                                              pretrained_model=self.current_model_path)
-        else:
-            self.current_model = model_name
-            self.current_model_path = os.fspath(
-                models.MODEL_DIR.joinpath(self.current_model))
-
-            self.model = models.CellposeModel(gpu=self.useGPU.isChecked(),
-                                             pretrained_model=self.current_model)
-
-    def add_model(self):
-        io._add_model(self)
-        return
-
-    def remove_model(self):
-        io._remove_model(self)
-        return
-
-    def new_model(self):
-        if self.NZ != 1:
-            print("ERROR: cannot train model on 3D data")
-            return
-
-        # train model
-        image_names = self.get_files()[0]
-        self.train_data, self.train_labels, self.train_files, restore, normalize_params = io._get_train_set(
-            image_names)
-        TW = guiparts.TrainWindow(self, models.MODEL_NAMES)
-        train = TW.exec_()
-        if train:
-            self.logger.info(
-                f"training with {[os.path.split(f)[1] for f in self.train_files]}")
-            self.train_model(restore=restore, normalize_params=normalize_params)
-        else:
-            print("GUI_INFO: training cancelled")
-
-    def train_model(self, restore=None, normalize_params=None):
-        from cellpose.models import normalize_default
-        if normalize_params is None:
-            normalize_params = copy.deepcopy(normalize_default)
-        model_type = models.MODEL_NAMES[self.training_params["model_index"]]
-        self.logger.info(f"training new model starting at model {model_type}")
-        self.current_model = model_type
-        
-        self.model = models.CellposeModel(gpu=self.useGPU.isChecked(),
-                                          model_type=model_type)
-        save_path = os.path.dirname(self.filename)
-
-        print("GUI_INFO: name of new model: " + self.training_params["model_name"])
-        self.new_model_path, train_losses = train.train_seg(
-            self.model.net, train_data=self.train_data, train_labels=self.train_labels,
-            normalize=normalize_params, min_train_masks=0,
-            save_path=save_path, nimg_per_epoch=max(2, len(self.train_data)),
-            learning_rate=self.training_params["learning_rate"],
-            weight_decay=self.training_params["weight_decay"],
-            n_epochs=self.training_params["n_epochs"],
-            model_name=self.training_params["model_name"])[:2]
-        # save train losses
-        np.save(str(self.new_model_path) + "_train_losses.npy", train_losses)
-        # run model on next image
-        io._add_model(self, self.new_model_path)
-        diam_labels = self.model.net.diam_labels.item()  #.copy()
-        self.new_model_ind = len(self.model_strings)
-        self.autorun = True
-        self.clear_all()
-        self.restore = restore
-        self.set_normalize_params(normalize_params)
-        self.get_next_image(load_seg=False)
-
-        self.compute_segmentation(custom=True)
-        self.logger.info(
-            f"!!! computed masks for {os.path.split(self.filename)[1]} from new model !!!"
-        )
-
-
-    def compute_cprob(self):
-        if self.recompute_masks:
-            flow_threshold = self.segmentation_settings.flow_threshold
-            cellprob_threshold = self.segmentation_settings.cellprob_threshold
-            niter = self.segmentation_settings.niter
-            min_size = int(self.min_size.text()) if not isinstance(
-                self.min_size, int) else self.min_size
-
-            self.logger.info(
-                    "computing masks with cell prob=%0.3f, flow error threshold=%0.3f" %
-                    (cellprob_threshold, flow_threshold))
-            
-            try:
-                dP = self.flows[2].squeeze()
-                cellprob = self.flows[3].squeeze()
-            except IndexError:
-                self.logger.error("Flows don't exist, try running model again.")
-                return
-            
-            maski = dynamics.resize_and_compute_masks(
-                dP=dP,
-                cellprob=cellprob,
-                niter=niter,
-                do_3D=self.load_3D,
-                min_size=min_size,
-                # max_size_fraction=min_size_fraction, # Leave as default 
-                cellprob_threshold=cellprob_threshold, 
-                flow_threshold=flow_threshold)
-            
-            self.masksOn = True
-            if not self.OCheckBox.isChecked():
-                self.MCheckBox.setChecked(True)
-            if maski.ndim < 3:
-                maski = maski[np.newaxis, ...]
-            self.logger.info("%d cells found" % (len(np.unique(maski)[1:])))
-            io._masks_to_gui(self, maski, outlines=None)
-            self.show()
-
-
-    def compute_segmentation(self, custom=False, model_name=None, load_model=True):
-        self.progress.setValue(0)
-        try:
-            tic = time.time()
-            self.clear_all()
-            self.flows = [[], [], []]
-            if load_model:
-                self.initialize_model(model_name=model_name, custom=custom)
-            self.progress.setValue(10)
-            do_3D = self.load_3D
-            stitch_threshold = float(self.stitch_threshold.text()) if not isinstance(
-                self.stitch_threshold, float) else self.stitch_threshold
-            anisotropy = float(self.anisotropy.text()) if not isinstance(
-                self.anisotropy, float) else self.anisotropy
-            flow3D_smooth = float(self.flow3D_smooth.text()) if not isinstance(
-                self.flow3D_smooth, float) else self.flow3D_smooth
-            min_size = int(self.min_size.text()) if not isinstance(
-                self.min_size, int) else self.min_size
-            
-            do_3D = False if stitch_threshold > 0. else do_3D
-
-            if self.restore == "filter":
-                data = self.stack_filtered.copy().squeeze()
-            else:
-                data = self.stack.copy().squeeze()
-            
-            flow_threshold = self.segmentation_settings.flow_threshold
-            cellprob_threshold = self.segmentation_settings.cellprob_threshold
-            diameter = self.segmentation_settings.diameter
-            niter = self.segmentation_settings.niter
-            
-            normalize_params = self.get_normalize_params()
-            print(normalize_params)
-            try:
-                masks, flows = self.model.eval(
-                    data, 
-                    diameter=diameter,
-                    cellprob_threshold=cellprob_threshold,
-                    flow_threshold=flow_threshold, do_3D=do_3D, niter=niter,
-                    normalize=normalize_params, stitch_threshold=stitch_threshold,
-                    anisotropy=anisotropy, flow3D_smooth=flow3D_smooth,
-                    min_size=min_size, channel_axis=-1,
-                    progress=self.progress, z_axis=0 if self.NZ > 1 else None)[:2]
-            except Exception as e:
-                print("NET ERROR: %s" % e)
-                self.progress.setValue(0)
-                return
-
-            self.progress.setValue(75)
-
-            # convert flows to uint8 and resize to original image size
-            flows_new = []
-            flows_new.append(flows[0].copy())  # RGB flow
-            flows_new.append((np.clip(normalize99(flows[2].copy()), 0, 1) *
-                              255).astype("uint8"))  # cellprob
-            flows_new.append(flows[1].copy()) # XY flows
-            flows_new.append(flows[2].copy()) # original cellprob
-
-            if self.load_3D:
-                if stitch_threshold == 0.:
-                    flows_new.append((flows[1][0] / 10 * 127 + 127).astype("uint8"))
-                else:
-                    flows_new.append(np.zeros(flows[1][0].shape, dtype="uint8"))
-
-            if not self.load_3D:
-                if self.restore and "upsample" in self.restore:
-                    self.Ly, self.Lx = self.Lyr, self.Lxr
-
-                if flows_new[0].shape[-3:-1] != (self.Ly, self.Lx):
-                    self.flows = []
-                    for j in range(len(flows_new)):
-                        self.flows.append(
-                            resize_image(flows_new[j], Ly=self.Ly, Lx=self.Lx,
-                                        interpolation=cv2.INTER_NEAREST))
-                else:
-                    self.flows = flows_new
-            else:
-                self.flows = []
-                Lz, Ly, Lx = self.NZ, self.Ly, self.Lx
-                Lz0, Ly0, Lx0 = flows_new[0].shape[:3]
-                print("GUI_INFO: resizing flows to original image size")
-                for j in range(len(flows_new)):
-                    flow0 = flows_new[j]
-                    if Ly0 != Ly:
-                        flow0 = resize_image(flow0, Ly=Ly, Lx=Lx,
-                                            no_channels=flow0.ndim==3, 
-                                            interpolation=cv2.INTER_NEAREST)
-                    if Lz0 != Lz:
-                        flow0 = np.swapaxes(resize_image(np.swapaxes(flow0, 0, 1),
-                                            Ly=Lz, Lx=Lx,
-                                            no_channels=flow0.ndim==3, 
-                                            interpolation=cv2.INTER_NEAREST), 0, 1)
-                    self.flows.append(flow0)
-
-            # add first axis
-            if self.NZ == 1:
-                masks = masks[np.newaxis, ...]
-                self.flows = [
-                    self.flows[n][np.newaxis, ...] for n in range(len(self.flows))
-                ]
-
-            self.logger.info("%d cells found with model in %0.3f sec" %
-                             (len(np.unique(masks)[1:]), time.time() - tic))
-            self.progress.setValue(80)
-            z = 0
-
-            io._masks_to_gui(self, masks, outlines=None)
-            self.masksOn = True
-            self.MCheckBox.setChecked(True)
-            self.progress.setValue(100)
-            if self.restore != "filter" and self.restore is not None and self.autobtn.isChecked():
-                self.compute_saturation()
-            if not do_3D and not stitch_threshold > 0:
-                self.recompute_masks = True
-            else:
-                self.recompute_masks = False
-        except Exception as e:
-            print("ERROR: %s" % e)

models/seg_post_model/cellpose/gui/gui3d.py

@@ -1,667 +0,0 @@
-"""
-Copyright © 2025 Howard Hughes Medical Institute, Authored by Carsen Stringer, Michael Rariden and Marius Pachitariu.
-"""
-
-import sys, pathlib, warnings
-
-from qtpy import QtGui, QtCore
-from qtpy.QtWidgets import QApplication, QScrollBar, QCheckBox, QLabel, QLineEdit
-import pyqtgraph as pg
-
-import numpy as np
-from scipy.stats import mode
-import cv2
-
-from . import guiparts, io
-from ..utils import download_url_to_file, masks_to_outlines
-from .gui import MainW
-
-try:
-    import matplotlib.pyplot as plt
-    MATPLOTLIB = True
-except:
-    MATPLOTLIB = False
-
-
-def avg3d(C):
-    """ smooth value of c across nearby points
-        (c is center of grid directly below point)
-        b -- a -- b
-        a -- c -- a
-        b -- a -- b
-    """
-    Ly, Lx = C.shape
-    # pad T by 2
-    T = np.zeros((Ly + 2, Lx + 2), "float32")
-    M = np.zeros((Ly, Lx), "float32")
-    T[1:-1, 1:-1] = C.copy()
-    y, x = np.meshgrid(np.arange(0, Ly, 1, int), np.arange(0, Lx, 1, int),
-                       indexing="ij")
-    y += 1
-    x += 1
-    a = 1. / 2  #/(z**2 + 1)**0.5
-    b = 1. / (1 + 2**0.5)  #(z**2 + 2)**0.5
-    c = 1.
-    M = (b * T[y - 1, x - 1] + a * T[y - 1, x] + b * T[y - 1, x + 1] + a * T[y, x - 1] +
-         c * T[y, x] + a * T[y, x + 1] + b * T[y + 1, x - 1] + a * T[y + 1, x] +
-         b * T[y + 1, x + 1])
-    M /= 4 * a + 4 * b + c
-    return M
-
-
-def interpZ(mask, zdraw):
-    """ find nearby planes and average their values using grid of points
-        zfill is in ascending order
-    """
-    ifill = np.ones(mask.shape[0], "bool")
-    zall = np.arange(0, mask.shape[0], 1, int)
-    ifill[zdraw] = False
-    zfill = zall[ifill]
-    zlower = zdraw[np.searchsorted(zdraw, zfill, side="left") - 1]
-    zupper = zdraw[np.searchsorted(zdraw, zfill, side="right")]
-    for k, z in enumerate(zfill):
-        Z = zupper[k] - zlower[k]
-        zl = (z - zlower[k]) / Z
-        plower = avg3d(mask[zlower[k]]) * (1 - zl)
-        pupper = avg3d(mask[zupper[k]]) * zl
-        mask[z] = (plower + pupper) > 0.33
-    return mask, zfill
-
-
-def run(image=None):
-    from ..io import logger_setup
-    logger, log_file = logger_setup()
-    # Always start by initializing Qt (only once per application)
-    warnings.filterwarnings("ignore")
-    app = QApplication(sys.argv)
-    icon_path = pathlib.Path.home().joinpath(".cellpose", "logo.png")
-    guip_path = pathlib.Path.home().joinpath(".cellpose", "cellpose_gui.png")
-    style_path = pathlib.Path.home().joinpath(".cellpose", "style_choice.npy")
-    if not icon_path.is_file():
-        cp_dir = pathlib.Path.home().joinpath(".cellpose")
-        cp_dir.mkdir(exist_ok=True)
-        print("downloading logo")
-        download_url_to_file(
-            "https://www.cellpose.org/static/images/cellpose_transparent.png",
-            icon_path, progress=True)
-    if not guip_path.is_file():
-        print("downloading help window image")
-        download_url_to_file("https://www.cellpose.org/static/images/cellpose_gui.png",
-                             guip_path, progress=True)
-    icon_path = str(icon_path.resolve())
-    app_icon = QtGui.QIcon()
-    app_icon.addFile(icon_path, QtCore.QSize(16, 16))
-    app_icon.addFile(icon_path, QtCore.QSize(24, 24))
-    app_icon.addFile(icon_path, QtCore.QSize(32, 32))
-    app_icon.addFile(icon_path, QtCore.QSize(48, 48))
-    app_icon.addFile(icon_path, QtCore.QSize(64, 64))
-    app_icon.addFile(icon_path, QtCore.QSize(256, 256))
-    app.setWindowIcon(app_icon)
-    app.setStyle("Fusion")
-    app.setPalette(guiparts.DarkPalette())
-    MainW_3d(image=image, logger=logger)
-    ret = app.exec_()
-    sys.exit(ret)
-
-
-class MainW_3d(MainW):
-
-    def __init__(self, image=None, logger=None):
-        # MainW init
-        MainW.__init__(self, image=image, logger=logger)
-
-        # add gradZ view
-        self.ViewDropDown.insertItem(3, "gradZ")
-
-        # turn off single stroke
-        self.SCheckBox.setChecked(False)
-
-        ### add orthoviews and z-bar
-        # ortho crosshair lines
-        self.vLine = pg.InfiniteLine(angle=90, movable=False)
-        self.hLine = pg.InfiniteLine(angle=0, movable=False)
-        self.vLineOrtho = [
-            pg.InfiniteLine(angle=90, movable=False),
-            pg.InfiniteLine(angle=90, movable=False)
-        ]
-        self.hLineOrtho = [
-            pg.InfiniteLine(angle=0, movable=False),
-            pg.InfiniteLine(angle=0, movable=False)
-        ]
-        self.make_orthoviews()
-
-        # z scrollbar underneath
-        self.scroll = QScrollBar(QtCore.Qt.Horizontal)
-        self.scroll.setMaximum(10)
-        self.scroll.valueChanged.connect(self.move_in_Z)
-        self.lmain.addWidget(self.scroll, 40, 9, 1, 30)
-
-        b = 22
-
-        label = QLabel("stitch\nthreshold:")
-        label.setToolTip(
-            "for 3D volumes, turn on stitch_threshold to stitch masks across planes instead of running cellpose in 3D (see docs for details)"
-        )
-        label.setFont(self.medfont)
-        self.segBoxG.addWidget(label, b, 0, 1, 4)
-        self.stitch_threshold = QLineEdit()
-        self.stitch_threshold.setText("0.0")
-        self.stitch_threshold.setFixedWidth(30)
-        self.stitch_threshold.setFont(self.medfont)
-        self.stitch_threshold.setToolTip(
-            "for 3D volumes, turn on stitch_threshold to stitch masks across planes instead of running cellpose in 3D (see docs for details)"
-        )
-        self.segBoxG.addWidget(self.stitch_threshold, b, 3, 1, 1)
-
-        label = QLabel("flow3D\nsmooth:")
-        label.setToolTip(
-            "for 3D volumes, smooth flows by a Gaussian with standard deviation flow3D_smooth (see docs for details)"
-        )
-        label.setFont(self.medfont)
-        self.segBoxG.addWidget(label, b, 4, 1, 3)
-        self.flow3D_smooth = QLineEdit()
-        self.flow3D_smooth.setText("0.0")
-        self.flow3D_smooth.setFixedWidth(30)
-        self.flow3D_smooth.setFont(self.medfont)
-        self.flow3D_smooth.setToolTip(
-            "for 3D volumes, smooth flows by a Gaussian with standard deviation flow3D_smooth (see docs for details)"
-        )
-        self.segBoxG.addWidget(self.flow3D_smooth, b, 7, 1, 1)
-
-        b+=1
-        label = QLabel("anisotropy:")
-        label.setToolTip(
-            "for 3D volumes, increase in sampling in Z vs XY as a ratio, e.g. set set to 2.0 if Z is sampled half as dense as X or Y (see docs for details)"
-        )
-        label.setFont(self.medfont)
-        self.segBoxG.addWidget(label, b, 0, 1, 3)
-        self.anisotropy = QLineEdit()
-        self.anisotropy.setText("1.0")
-        self.anisotropy.setFixedWidth(30)
-        self.anisotropy.setFont(self.medfont)
-        self.anisotropy.setToolTip(
-            "for 3D volumes, increase in sampling in Z vs XY as a ratio, e.g. set set to 2.0 if Z is sampled half as dense as X or Y (see docs for details)"
-        )
-        self.segBoxG.addWidget(self.anisotropy, b, 3, 1, 1)
-
-        b+=1
-        label = QLabel("min\nsize:")
-        label.setToolTip(
-            "all masks less than this size in pixels (volume) will be removed"
-        )
-        label.setFont(self.medfont)
-        self.segBoxG.addWidget(label, b, 0, 1, 4)
-        self.min_size = QLineEdit()
-        self.min_size.setText("15")
-        self.min_size.setFixedWidth(50)
-        self.min_size.setFont(self.medfont)
-        self.min_size.setToolTip(
-            "all masks less than this size in pixels (volume) will be removed"
-        )
-        self.segBoxG.addWidget(self.min_size, b, 3, 1, 1)
-
-        b += 1
-        self.orthobtn = QCheckBox("ortho")
-        self.orthobtn.setToolTip("activate orthoviews with 3D image")
-        self.orthobtn.setFont(self.medfont)
-        self.orthobtn.setChecked(False)
-        self.l0.addWidget(self.orthobtn, b, 0, 1, 2)
-        self.orthobtn.toggled.connect(self.toggle_ortho)
-
-        label = QLabel("dz:")
-        label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        label.setFont(self.medfont)
-        self.l0.addWidget(label, b, 2, 1, 1)
-        self.dz = 10
-        self.dzedit = QLineEdit()
-        self.dzedit.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.dzedit.setText(str(self.dz))
-        self.dzedit.returnPressed.connect(self.update_ortho)
-        self.dzedit.setFixedWidth(40)
-        self.dzedit.setFont(self.medfont)
-        self.l0.addWidget(self.dzedit, b, 3, 1, 2)
-
-        label = QLabel("z-aspect:")
-        label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        label.setFont(self.medfont)
-        self.l0.addWidget(label, b, 5, 1, 2)
-        self.zaspect = 1.0
-        self.zaspectedit = QLineEdit()
-        self.zaspectedit.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.zaspectedit.setText(str(self.zaspect))
-        self.zaspectedit.returnPressed.connect(self.update_ortho)
-        self.zaspectedit.setFixedWidth(40)
-        self.zaspectedit.setFont(self.medfont)
-        self.l0.addWidget(self.zaspectedit, b, 7, 1, 2)
-
-        b += 1
-        # add z position underneath
-        self.currentZ = 0
-        label = QLabel("Z:")
-        label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.l0.addWidget(label, b, 5, 1, 2)
-        self.zpos = QLineEdit()
-        self.zpos.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.zpos.setText(str(self.currentZ))
-        self.zpos.returnPressed.connect(self.update_ztext)
-        self.zpos.setFixedWidth(40)
-        self.zpos.setFont(self.medfont)
-        self.l0.addWidget(self.zpos, b, 7, 1, 2)
-
-        # if called with image, load it
-        if image is not None:
-            self.filename = image
-            io._load_image(self, self.filename, load_3D=True)
-
-        self.load_3D = True
-
-    def add_mask(self, points=None, color=(100, 200, 50), dense=True):
-        # points is list of strokes
-
-        points_all = np.concatenate(points, axis=0)
-
-        # loop over z values
-        median = []
-        zdraw = np.unique(points_all[:, 0])
-        zrange = np.arange(zdraw.min(), zdraw.max() + 1, 1, int)
-        zmin = zdraw.min()
-        pix = np.zeros((2, 0), "uint16")
-        mall = np.zeros((len(zrange), self.Ly, self.Lx), "bool")
-        k = 0
-        for z in zdraw:
-            ars, acs, vrs, vcs = np.zeros(0, "int"), np.zeros(0, "int"), np.zeros(
-                0, "int"), np.zeros(0, "int")
-            for stroke in points:
-                stroke = np.concatenate(stroke, axis=0).reshape(-1, 4)
-                iz = stroke[:, 0] == z
-                vr = stroke[iz, 1]
-                vc = stroke[iz, 2]
-                if iz.sum() > 0:
-                    # get points inside drawn points
-                    mask = np.zeros((np.ptp(vr) + 4, np.ptp(vc) + 4), "uint8")
-                    pts = np.stack((vc - vc.min() + 2, vr - vr.min() + 2),
-                                   axis=-1)[:, np.newaxis, :]
-                    mask = cv2.fillPoly(mask, [pts], (255, 0, 0))
-                    ar, ac = np.nonzero(mask)
-                    ar, ac = ar + vr.min() - 2, ac + vc.min() - 2
-                    # get dense outline
-                    contours = cv2.findContours(mask, cv2.RETR_EXTERNAL,
-                                                cv2.CHAIN_APPROX_NONE)
-                    pvc, pvr = contours[-2][0].squeeze().T
-                    vr, vc = pvr + vr.min() - 2, pvc + vc.min() - 2
-                    # concatenate all points
-                    ar, ac = np.hstack((np.vstack((vr, vc)), np.vstack((ar, ac))))
-                    # if these pixels are overlapping with another cell, reassign them
-                    ioverlap = self.cellpix[z][ar, ac] > 0
-                    if (~ioverlap).sum() < 8:
-                        print("ERROR: cell too small without overlaps, not drawn")
-                        return None
-                    elif ioverlap.sum() > 0:
-                        ar, ac = ar[~ioverlap], ac[~ioverlap]
-                        # compute outline of new mask
-                        mask = np.zeros((np.ptp(ar) + 4, np.ptp(ac) + 4), "uint8")
-                        mask[ar - ar.min() + 2, ac - ac.min() + 2] = 1
-                        contours = cv2.findContours(mask, cv2.RETR_EXTERNAL,
-                                                    cv2.CHAIN_APPROX_NONE)
-                        pvc, pvr = contours[-2][0].squeeze().T
-                        vr, vc = pvr + ar.min() - 2, pvc + ac.min() - 2
-                    ars = np.concatenate((ars, ar), axis=0)
-                    acs = np.concatenate((acs, ac), axis=0)
-                    vrs = np.concatenate((vrs, vr), axis=0)
-                    vcs = np.concatenate((vcs, vc), axis=0)
-            self.draw_mask(z, ars, acs, vrs, vcs, color)
-
-            median.append(np.array([np.median(ars), np.median(acs)]))
-            mall[z - zmin, ars, acs] = True
-            pix = np.append(pix, np.vstack((ars, acs)), axis=-1)
-
-        mall = mall[:, pix[0].min():pix[0].max() + 1,
-                    pix[1].min():pix[1].max() + 1].astype("float32")
-        ymin, xmin = pix[0].min(), pix[1].min()
-        if len(zdraw) > 1:
-            mall, zfill = interpZ(mall, zdraw - zmin)
-            for z in zfill:
-                mask = mall[z].copy()
-                ar, ac = np.nonzero(mask)
-                ioverlap = self.cellpix[z + zmin][ar + ymin, ac + xmin] > 0
-                if (~ioverlap).sum() < 5:
-                    print("WARNING: stroke on plane %d not included due to overlaps" %
-                          z)
-                elif ioverlap.sum() > 0:
-                    mask[ar[ioverlap], ac[ioverlap]] = 0
-                    ar, ac = ar[~ioverlap], ac[~ioverlap]
-                # compute outline of mask
-                outlines = masks_to_outlines(mask)
-                vr, vc = np.nonzero(outlines)
-                vr, vc = vr + ymin, vc + xmin
-                ar, ac = ar + ymin, ac + xmin
-                self.draw_mask(z + zmin, ar, ac, vr, vc, color)
-
-        self.zdraw.append(zdraw)
-
-        return median
-
-    def move_in_Z(self):
-        if self.loaded:
-            self.currentZ = min(self.NZ, max(0, int(self.scroll.value())))
-            self.zpos.setText(str(self.currentZ))
-            self.update_plot()
-            self.draw_layer()
-            self.update_layer()
-
-    def make_orthoviews(self):
-        self.pOrtho, self.imgOrtho, self.layerOrtho = [], [], []
-        for j in range(2):
-            self.pOrtho.append(
-                pg.ViewBox(lockAspect=True, name=f"plotOrtho{j}",
-                           border=[100, 100, 100], invertY=True, enableMouse=False))
-            self.pOrtho[j].setMenuEnabled(False)
-
-            self.imgOrtho.append(pg.ImageItem(viewbox=self.pOrtho[j], parent=self))
-            self.imgOrtho[j].autoDownsample = False
-
-            self.layerOrtho.append(pg.ImageItem(viewbox=self.pOrtho[j], parent=self))
-            self.layerOrtho[j].setLevels([0., 255.])
-
-            #self.pOrtho[j].scene().contextMenuItem = self.pOrtho[j]
-            self.pOrtho[j].addItem(self.imgOrtho[j])
-            self.pOrtho[j].addItem(self.layerOrtho[j])
-            self.pOrtho[j].addItem(self.vLineOrtho[j], ignoreBounds=False)
-            self.pOrtho[j].addItem(self.hLineOrtho[j], ignoreBounds=False)
-
-        self.pOrtho[0].linkView(self.pOrtho[0].YAxis, self.p0)
-        self.pOrtho[1].linkView(self.pOrtho[1].XAxis, self.p0)
-
-    def add_orthoviews(self):
-        self.yortho = self.Ly // 2
-        self.xortho = self.Lx // 2
-        if self.NZ > 1:
-            self.update_ortho()
-
-        self.win.addItem(self.pOrtho[0], 0, 1, rowspan=1, colspan=1)
-        self.win.addItem(self.pOrtho[1], 1, 0, rowspan=1, colspan=1)
-
-        qGraphicsGridLayout = self.win.ci.layout
-        qGraphicsGridLayout.setColumnStretchFactor(0, 2)
-        qGraphicsGridLayout.setColumnStretchFactor(1, 1)
-        qGraphicsGridLayout.setRowStretchFactor(0, 2)
-        qGraphicsGridLayout.setRowStretchFactor(1, 1)
-
-        self.pOrtho[0].setYRange(0, self.Lx)
-        self.pOrtho[0].setXRange(-self.dz / 3, self.dz * 2 + self.dz / 3)
-        self.pOrtho[1].setYRange(-self.dz / 3, self.dz * 2 + self.dz / 3)
-        self.pOrtho[1].setXRange(0, self.Ly)
-
-        self.p0.addItem(self.vLine, ignoreBounds=False)
-        self.p0.addItem(self.hLine, ignoreBounds=False)
-        self.p0.setYRange(0, self.Lx)
-        self.p0.setXRange(0, self.Ly)
-
-        self.win.show()
-        self.show()
-
-    def remove_orthoviews(self):
-        self.win.removeItem(self.pOrtho[0])
-        self.win.removeItem(self.pOrtho[1])
-        self.p0.removeItem(self.vLine)
-        self.p0.removeItem(self.hLine)
-        self.win.show()
-        self.show()
-
-    def update_crosshairs(self):
-        self.yortho = min(self.Ly - 1, max(0, int(self.yortho)))
-        self.xortho = min(self.Lx - 1, max(0, int(self.xortho)))
-        self.vLine.setPos(self.xortho)
-        self.hLine.setPos(self.yortho)
-        self.vLineOrtho[1].setPos(self.xortho)
-        self.hLineOrtho[1].setPos(self.zc)
-        self.vLineOrtho[0].setPos(self.zc)
-        self.hLineOrtho[0].setPos(self.yortho)
-
-    def update_ortho(self):
-        if self.NZ > 1 and self.orthobtn.isChecked():
-            dzcurrent = self.dz
-            self.dz = min(100, max(3, int(self.dzedit.text())))
-            self.zaspect = max(0.01, min(100., float(self.zaspectedit.text())))
-            self.dzedit.setText(str(self.dz))
-            self.zaspectedit.setText(str(self.zaspect))
-            if self.dz != dzcurrent:
-                self.pOrtho[0].setXRange(-self.dz / 3, self.dz * 2 + self.dz / 3)
-                self.pOrtho[1].setYRange(-self.dz / 3, self.dz * 2 + self.dz / 3)
-            dztot = min(self.NZ, self.dz * 2)
-            y = self.yortho
-            x = self.xortho
-            z = self.currentZ
-            if dztot == self.NZ:
-                zmin, zmax = 0, self.NZ
-            else:
-                if z - self.dz < 0:
-                    zmin = 0
-                    zmax = zmin + self.dz * 2
-                elif z + self.dz >= self.NZ:
-                    zmax = self.NZ
-                    zmin = zmax - self.dz * 2
-                else:
-                    zmin, zmax = z - self.dz, z + self.dz
-            self.zc = z - zmin
-            self.update_crosshairs()
-            if self.view == 0 or self.view == 4:
-                for j in range(2):
-                    if j == 0:
-                        if self.view == 0:
-                            image = self.stack[zmin:zmax, :, x].transpose(1, 0, 2).copy()
-                        else:
-                            image = self.stack_filtered[zmin:zmax, :,
-                                                        x].transpose(1, 0, 2).copy()
-                    else:
-                        image = self.stack[
-                            zmin:zmax,
-                            y, :].copy() if self.view == 0 else self.stack_filtered[zmin:zmax,
-                                                                             y, :].copy()
-                    if self.nchan == 1:
-                        # show single channel
-                        image = image[..., 0]
-                    if self.color == 0:
-                        self.imgOrtho[j].setImage(image, autoLevels=False, lut=None)
-                        if self.nchan > 1:
-                            levels = np.array([
-                                self.saturation[0][self.currentZ],
-                                self.saturation[1][self.currentZ],
-                                self.saturation[2][self.currentZ]
-                            ])
-                            self.imgOrtho[j].setLevels(levels)
-                        else:
-                            self.imgOrtho[j].setLevels(
-                                self.saturation[0][self.currentZ])
-                    elif self.color > 0 and self.color < 4:
-                        if self.nchan > 1:
-                            image = image[..., self.color - 1]
-                        self.imgOrtho[j].setImage(image, autoLevels=False,
-                                                  lut=self.cmap[self.color])
-                        if self.nchan > 1:
-                            self.imgOrtho[j].setLevels(
-                                self.saturation[self.color - 1][self.currentZ])
-                        else:
-                            self.imgOrtho[j].setLevels(
-                                self.saturation[0][self.currentZ])
-                    elif self.color == 4:
-                        if image.ndim > 2:
-                            image = image.astype("float32").mean(axis=2).astype("uint8")
-                        self.imgOrtho[j].setImage(image, autoLevels=False, lut=None)
-                        self.imgOrtho[j].setLevels(self.saturation[0][self.currentZ])
-                    elif self.color == 5:
-                        if image.ndim > 2:
-                            image = image.astype("float32").mean(axis=2).astype("uint8")
-                        self.imgOrtho[j].setImage(image, autoLevels=False,
-                                                  lut=self.cmap[0])
-                        self.imgOrtho[j].setLevels(self.saturation[0][self.currentZ])
-                self.pOrtho[0].setAspectLocked(lock=True, ratio=self.zaspect)
-                self.pOrtho[1].setAspectLocked(lock=True, ratio=1. / self.zaspect)
-
-            else:
-                image = np.zeros((10, 10), "uint8")
-                self.imgOrtho[0].setImage(image, autoLevels=False, lut=None)
-                self.imgOrtho[0].setLevels([0.0, 255.0])
-                self.imgOrtho[1].setImage(image, autoLevels=False, lut=None)
-                self.imgOrtho[1].setLevels([0.0, 255.0])
-
-        zrange = zmax - zmin
-        self.layer_ortho = [
-            np.zeros((self.Ly, zrange, 4), "uint8"),
-            np.zeros((zrange, self.Lx, 4), "uint8")
-        ]
-        if self.masksOn:
-            for j in range(2):
-                if j == 0:
-                    cp = self.cellpix[zmin:zmax, :, x].T
-                else:
-                    cp = self.cellpix[zmin:zmax, y]
-                self.layer_ortho[j][..., :3] = self.cellcolors[cp, :]
-                self.layer_ortho[j][..., 3] = self.opacity * (cp > 0).astype("uint8")
-                if self.selected > 0:
-                    self.layer_ortho[j][cp == self.selected] = np.array(
-                        [255, 255, 255, self.opacity])
-
-        if self.outlinesOn:
-            for j in range(2):
-                if j == 0:
-                    op = self.outpix[zmin:zmax, :, x].T
-                else:
-                    op = self.outpix[zmin:zmax, y]
-                self.layer_ortho[j][op > 0] = np.array(self.outcolor).astype("uint8")
-
-        for j in range(2):
-            self.layerOrtho[j].setImage(self.layer_ortho[j])
-        self.win.show()
-        self.show()
-
-    def toggle_ortho(self):
-        if self.orthobtn.isChecked():
-            self.add_orthoviews()
-        else:
-            self.remove_orthoviews()
-
-    def plot_clicked(self, event):
-        if event.button()==QtCore.Qt.LeftButton \
-                and not event.modifiers() & (QtCore.Qt.ShiftModifier | QtCore.Qt.AltModifier)\
-                and not self.removing_region:
-            if event.double():
-                try:
-                    self.p0.setYRange(0, self.Ly + self.pr)
-                except:
-                    self.p0.setYRange(0, self.Ly)
-                self.p0.setXRange(0, self.Lx)
-            elif self.loaded and not self.in_stroke:
-                if self.orthobtn.isChecked():
-                    items = self.win.scene().items(event.scenePos())
-                    for x in items:
-                        if x == self.p0:
-                            pos = self.p0.mapSceneToView(event.scenePos())
-                            x = int(pos.x())
-                            y = int(pos.y())
-                            if y >= 0 and y < self.Ly and x >= 0 and x < self.Lx:
-                                self.yortho = y
-                                self.xortho = x
-                                self.update_ortho()
-
-    def update_plot(self):
-        super().update_plot()
-        if self.NZ > 1 and self.orthobtn.isChecked():
-            self.update_ortho()
-        self.win.show()
-        self.show()
-
-    def keyPressEvent(self, event):
-        if self.loaded:
-            if not (event.modifiers() &
-                    (QtCore.Qt.ControlModifier | QtCore.Qt.ShiftModifier |
-                     QtCore.Qt.AltModifier) or self.in_stroke):
-                updated = False
-                if len(self.current_point_set) > 0:
-                    if event.key() == QtCore.Qt.Key_Return:
-                        self.add_set()
-                    if self.NZ > 1:
-                        if event.key() == QtCore.Qt.Key_Left:
-                            self.currentZ = max(0, self.currentZ - 1)
-                            self.scroll.setValue(self.currentZ)
-                            updated = True
-                        elif event.key() == QtCore.Qt.Key_Right:
-                            self.currentZ = min(self.NZ - 1, self.currentZ + 1)
-                            self.scroll.setValue(self.currentZ)
-                            updated = True
-                else:
-                    nviews = self.ViewDropDown.count() - 1
-                    nviews += int(
-                        self.ViewDropDown.model().item(self.ViewDropDown.count() -
-                                                       1).isEnabled())
-                    if event.key() == QtCore.Qt.Key_X:
-                        self.MCheckBox.toggle()
-                    if event.key() == QtCore.Qt.Key_Z:
-                        self.OCheckBox.toggle()
-                    if event.key() == QtCore.Qt.Key_Left or event.key(
-                    ) == QtCore.Qt.Key_A:
-                        self.currentZ = max(0, self.currentZ - 1)
-                        self.scroll.setValue(self.currentZ)
-                        updated = True
-                    elif event.key() == QtCore.Qt.Key_Right or event.key(
-                    ) == QtCore.Qt.Key_D:
-                        self.currentZ = min(self.NZ - 1, self.currentZ + 1)
-                        self.scroll.setValue(self.currentZ)
-                        updated = True
-                    elif event.key() == QtCore.Qt.Key_PageDown:
-                        self.view = (self.view + 1) % (nviews)
-                        self.ViewDropDown.setCurrentIndex(self.view)
-                    elif event.key() == QtCore.Qt.Key_PageUp:
-                        self.view = (self.view - 1) % (nviews)
-                        self.ViewDropDown.setCurrentIndex(self.view)
-
-                # can change background or stroke size if cell not finished
-                if event.key() == QtCore.Qt.Key_Up or event.key() == QtCore.Qt.Key_W:
-                    self.color = (self.color - 1) % (6)
-                    self.RGBDropDown.setCurrentIndex(self.color)
-                elif event.key() == QtCore.Qt.Key_Down or event.key(
-                ) == QtCore.Qt.Key_S:
-                    self.color = (self.color + 1) % (6)
-                    self.RGBDropDown.setCurrentIndex(self.color)
-                elif event.key() == QtCore.Qt.Key_R:
-                    if self.color != 1:
-                        self.color = 1
-                    else:
-                        self.color = 0
-                    self.RGBDropDown.setCurrentIndex(self.color)
-                elif event.key() == QtCore.Qt.Key_G:
-                    if self.color != 2:
-                        self.color = 2
-                    else:
-                        self.color = 0
-                    self.RGBDropDown.setCurrentIndex(self.color)
-                elif event.key() == QtCore.Qt.Key_B:
-                    if self.color != 3:
-                        self.color = 3
-                    else:
-                        self.color = 0
-                    self.RGBDropDown.setCurrentIndex(self.color)
-                elif (event.key() == QtCore.Qt.Key_Comma or
-                      event.key() == QtCore.Qt.Key_Period):
-                    count = self.BrushChoose.count()
-                    gci = self.BrushChoose.currentIndex()
-                    if event.key() == QtCore.Qt.Key_Comma:
-                        gci = max(0, gci - 1)
-                    else:
-                        gci = min(count - 1, gci + 1)
-                    self.BrushChoose.setCurrentIndex(gci)
-                    self.brush_choose()
-                if not updated:
-                    self.update_plot()
-        if event.key() == QtCore.Qt.Key_Minus or event.key() == QtCore.Qt.Key_Equal:
-            self.p0.keyPressEvent(event)
-
-    def update_ztext(self):
-        zpos = self.currentZ
-        try:
-            zpos = int(self.zpos.text())
-        except:
-            print("ERROR: zposition is not a number")
-        self.currentZ = max(0, min(self.NZ - 1, zpos))
-        self.zpos.setText(str(self.currentZ))
-        self.scroll.setValue(self.currentZ)

models/seg_post_model/cellpose/gui/guihelpwindowtext.html

@@ -1,143 +0,0 @@
-<qt>
-    <p class="has-line-data" data-line-start="5" data-line-end="6">
-        <b>Main GUI mouse controls:</b>
-    </p>
-    <ul>
-        <li class="has-line-data" data-line-start="7" data-line-end="8">Pan = left-click + drag</li>
-        <li class="has-line-data" data-line-start="8" data-line-end="9">Zoom = scroll wheel (or +/= and - buttons)</li>
-        <li class="has-line-data" data-line-start="9" data-line-end="10">Full view = double left-click</li>
-        <li class="has-line-data" data-line-start="10" data-line-end="11">Select mask = left-click on mask</li>
-        <li class="has-line-data" data-line-start="11" data-line-end="12">Delete mask = Ctrl (or COMMAND on Mac) +
-            left-click
-        </li>
-        <li class="has-line-data" data-line-start="11" data-line-end="12">Merge masks = Alt + left-click (will merge
-            last two)
-        </li>
-        <li class="has-line-data" data-line-start="12" data-line-end="13">Start draw mask = right-click</li>
-        <li class="has-line-data" data-line-start="13" data-line-end="15">End draw mask = right-click, or return to
-            circle at beginning
-        </li>
-    </ul>
-    <p class="has-line-data" data-line-start="15" data-line-end="16">Overlaps in masks are NOT allowed. If you
-        draw a mask on top of another mask, it is cropped so that it doesn’t overlap with the old mask. Masks in 2D
-        should be single strokes (single stroke is checked). If you want to draw masks in 3D (experimental), then
-        you can turn this option off and draw a stroke on each plane with the cell and then press ENTER. 3D
-        labelling will fill in planes that you have not labelled so that you do not have to as densely label.
-    </p>
-    <p class="has-line-data" data-line-start="17" data-line-end="18"> <b>!NOTE!:</b> The GUI automatically saves after
-        you draw a mask in 2D but NOT after 3D mask drawing and NOT after segmentation. Save in the file menu or
-        with Ctrl+S. The output file is in the same folder as the loaded image with <code>_seg.npy</code> appended.
-    </p>
-
-    <p class="has-line-data" data-line-start="19" data-line-end="20"> <b>Bulk Mask Deletion</b>
-        Clicking the 'delete multiple' button will allow you to select and delete multiple masks at once.
-        Masks can be deselected by clicking on them again. Once you have selected all the masks you want to delete,
-        click the 'done' button to delete them.
-        <br>
-        <br>
-        Alternatively, you can create a rectangular region to delete a regions of masks by clicking the
-        'delete multiple' button, and then moving and/or resizing the region to select the masks you want to delete.
-        Once you have selected the masks you want to delete, click the 'done' button to delete them.
-        <br>
-        <br>
-        At any point in the process, you can click the 'cancel' button to cancel the bulk deletion.
-    </p>
-    <hr>
-    <table class="table table-striped table-bordered">
-        <br>
-        <br>
-        FYI there are tooltips throughout the GUI (hover over text to see)
-        <br>
-        <thead>
-        <tr>
-            <th>Keyboard shortcuts</th>
-            <th>Description</th>
-        </tr>
-        </thead>
-        <tbody>
-        <tr>
-            <td>=/+ button // - button</td>
-            <td>zoom in // zoom out</td>
-        </tr>
-        <tr>
-            <td>CTRL+Z</td>
-            <td>undo previously drawn mask/stroke</td>
-        </tr>
-        <tr>
-            <td>CTRL+Y</td>
-            <td>undo remove mask</td>
-        </tr>
-        <tr>
-            <td>CTRL+0</td>
-            <td>clear all masks</td>
-        </tr>
-        <tr>
-            <td>CTRL+L</td>
-            <td>load image (can alternatively drag and drop image)</td>
-        </tr>
-        <tr>
-            <td>CTRL+S</td>
-            <td>SAVE MASKS IN IMAGE to <code>_seg.npy</code> file</td>
-        </tr>
-        <tr>
-            <td>CTRL+T</td>
-            <td>train model using _seg.npy files in folder
-        </tr>
-        <tr>
-            <td>CTRL+P</td>
-            <td>load <code>_seg.npy</code> file (note: it will load automatically with image if it exists)</td>
-        </tr>
-        <tr>
-            <td>CTRL+M</td>
-            <td>load masks file (must be same size as image with 0 for NO mask, and 1,2,3… for masks)</td>
-        </tr>
-        <tr>
-            <td>CTRL+N</td>
-            <td>save masks as PNG</td>
-        </tr>
-        <tr>
-            <td>CTRL+R</td>
-            <td>save ROIs to native ImageJ ROI format</td>
-        </tr>
-        <tr>
-            <td>CTRL+F</td>
-            <td>save flows to image file</td>
-        </tr>
-        <tr>
-            <td>A/D or LEFT/RIGHT</td>
-            <td>cycle through images in current directory</td>
-        </tr>
-        <tr>
-            <td>W/S or UP/DOWN</td>
-            <td>change color (RGB/gray/red/green/blue)</td>
-        </tr>
-        <tr>
-            <td>R / G / B</td>
-            <td>toggle between RGB and Red or Green or Blue</td>
-        </tr>
-        <tr>
-            <td>PAGE-UP / PAGE-DOWN</td>
-            <td>change to flows and cell prob views (if segmentation computed)</td>
-        </tr>
-        <tr>
-            <td>X</td>
-            <td>turn masks ON or OFF</td>
-        </tr>
-        <tr>
-            <td>Z</td>
-            <td>toggle outlines ON or OFF</td>
-        </tr>
-        <tr>
-            <td>, / .</td>
-            <td>increase / decrease brush size for drawing masks</td>
-        </tr>
-        </tbody>
-    </table>
-    <p class="has-line-data" data-line-start="36" data-line-end="37"><strong>Segmentation options 
-        (2D only) </strong></p>
-    <p class="has-line-data" data-line-start="38" data-line-end="39">use GPU: if you have specially 
-        installed the cuda version of torch, then you can activate this. Due to the size of the 
-        transformer network, it will greatly speed up the processing time.</p>
-    <p class="has-line-data" data-line-start="40" data-line-end="41">There are no channel options
-        in v4.0.1+ since all 3 channels are used for segmentation. </p>
-</qt>

models/seg_post_model/cellpose/gui/guiparts.py

@@ -1,793 +0,0 @@
-"""
-Copyright © 2025 Howard Hughes Medical Institute, Authored by Carsen Stringer , Michael Rariden and Marius Pachitariu.
-"""
-from qtpy import QtGui, QtCore
-from qtpy.QtGui import QPixmap, QDoubleValidator
-from qtpy.QtWidgets import QWidget, QDialog, QGridLayout, QPushButton, QLabel, QLineEdit, QDialogButtonBox, QComboBox, QCheckBox, QVBoxLayout
-import pyqtgraph as pg
-import numpy as np
-import pathlib, os
-
-
-def stylesheet():
-    return """
-        QToolTip { 
-                            background-color: black; 
-                            color: white; 
-                            border: black solid 1px
-                            }
-        QComboBox {color: white;
-                    background-color: rgb(40,40,40);}
-                    QComboBox::item:enabled { color: white;
-                    background-color: rgb(40,40,40);
-                    selection-color: white;
-                    selection-background-color: rgb(50,100,50);}
-                    QComboBox::item:!enabled {
-                            background-color: rgb(40,40,40);
-                            color: rgb(100,100,100);
-                        }
-        QScrollArea > QWidget > QWidget
-                {
-                    background: transparent;
-                    border: none;
-                    margin: 0px 0px 0px 0px;
-                } 
-                           
-        QGroupBox 
-            { border: 1px solid white; color: rgb(255,255,255);
-                           border-radius: 6px;
-                            margin-top: 8px;
-                            padding: 0px 0px;}            
-                           
-        QPushButton:pressed {Text-align: center; 
-                             background-color: rgb(150,50,150); 
-                             border-color: white;
-                             color:white;}
-                            QToolTip { 
-                           background-color: black; 
-                           color: white; 
-                           border: black solid 1px
-                           }
-        QPushButton:!pressed {Text-align: center; 
-                               background-color: rgb(50,50,50);
-                                border-color: white;
-                               color:white;}
-                                QToolTip { 
-                           background-color: black; 
-                           color: white; 
-                           border: black solid 1px
-                           }
-        QPushButton:disabled {Text-align: center; 
-                             background-color: rgb(30,30,30);
-                             border-color: white;
-                              color:rgb(80,80,80);}
-                               QToolTip { 
-                           background-color: black; 
-                           color: white; 
-                           border: black solid 1px
-                           }
-                        
-        """
-
-
-class DarkPalette(QtGui.QPalette):
-    """Class that inherits from pyqtgraph.QtGui.QPalette and renders dark colours for the application.
-    (from pykilosort/kilosort4)
-    """
-
-    def __init__(self):
-        QtGui.QPalette.__init__(self)
-        self.setup()
-
-    def setup(self):
-        self.setColor(QtGui.QPalette.Window, QtGui.QColor(40, 40, 40))
-        self.setColor(QtGui.QPalette.WindowText, QtGui.QColor(255, 255, 255))
-        self.setColor(QtGui.QPalette.Base, QtGui.QColor(34, 27, 24))
-        self.setColor(QtGui.QPalette.AlternateBase, QtGui.QColor(53, 50, 47))
-        self.setColor(QtGui.QPalette.ToolTipBase, QtGui.QColor(255, 255, 255))
-        self.setColor(QtGui.QPalette.ToolTipText, QtGui.QColor(255, 255, 255))
-        self.setColor(QtGui.QPalette.Text, QtGui.QColor(255, 255, 255))
-        self.setColor(QtGui.QPalette.Button, QtGui.QColor(53, 50, 47))
-        self.setColor(QtGui.QPalette.ButtonText, QtGui.QColor(255, 255, 255))
-        self.setColor(QtGui.QPalette.BrightText, QtGui.QColor(255, 0, 0))
-        self.setColor(QtGui.QPalette.Link, QtGui.QColor(42, 130, 218))
-        self.setColor(QtGui.QPalette.Highlight, QtGui.QColor(42, 130, 218))
-        self.setColor(QtGui.QPalette.HighlightedText, QtGui.QColor(0, 0, 0))
-        self.setColor(QtGui.QPalette.Disabled, QtGui.QPalette.Text,
-                      QtGui.QColor(128, 128, 128))
-        self.setColor(
-            QtGui.QPalette.Disabled,
-            QtGui.QPalette.ButtonText,
-            QtGui.QColor(128, 128, 128),
-        )
-        self.setColor(
-            QtGui.QPalette.Disabled,
-            QtGui.QPalette.WindowText,
-            QtGui.QColor(128, 128, 128),
-        )
-
-
-# def create_channel_choose():
-#     # choose channel
-#     ChannelChoose = [QComboBox(), QComboBox()]
-#     ChannelLabels = []
-#     ChannelChoose[0].addItems(["gray", "red", "green", "blue"])
-#     ChannelChoose[1].addItems(["none", "red", "green", "blue"])
-#     cstr = ["chan to segment:", "chan2 (optional): "]
-#     for i in range(2):
-#         ChannelLabels.append(QLabel(cstr[i]))
-#         if i == 0:
-#             ChannelLabels[i].setToolTip(
-#                 "this is the channel in which the cytoplasm or nuclei exist \
-#             that you want to segment")
-#             ChannelChoose[i].setToolTip(
-#                 "this is the channel in which the cytoplasm or nuclei exist \
-#             that you want to segment")
-#         else:
-#             ChannelLabels[i].setToolTip(
-#                 "if <em>cytoplasm</em> model is chosen, and you also have a \
-#             nuclear channel, then choose the nuclear channel for this option")
-#             ChannelChoose[i].setToolTip(
-#                 "if <em>cytoplasm</em> model is chosen, and you also have a \
-#             nuclear channel, then choose the nuclear channel for this option")
-
-#     return ChannelChoose, ChannelLabels
-
-
-class ModelButton(QPushButton):
-
-    def __init__(self, parent, model_name, text):
-        super().__init__()
-        self.setEnabled(False)
-        self.setText(text)
-        self.setFont(parent.boldfont)
-        self.clicked.connect(lambda: self.press(parent))
-        self.model_name = "cpsam"
-
-    def press(self, parent):
-        parent.compute_segmentation(model_name="cpsam")
-
-
-class FilterButton(QPushButton):
-
-    def __init__(self, parent, text):
-        super().__init__()
-        self.setEnabled(False)
-        self.model_type = text
-        self.setText(text)
-        self.setFont(parent.medfont)
-        self.clicked.connect(lambda: self.press(parent))
-
-    def press(self, parent):
-        if self.model_type == "filter":
-            parent.restore = "filter"
-            normalize_params = parent.get_normalize_params()
-            if (normalize_params["sharpen_radius"] == 0 and
-                    normalize_params["smooth_radius"] == 0 and
-                    normalize_params["tile_norm_blocksize"] == 0):
-                print(
-                    "GUI_ERROR: no filtering settings on (use custom filter settings)")
-                parent.restore = None
-                return
-            parent.restore = self.model_type
-            parent.compute_saturation()
-        # elif self.model_type != "none":
-        #     parent.compute_denoise_model(model_type=self.model_type)
-        else:
-            parent.clear_restore()
-        # parent.set_restore_button()
-
-
-class ObservableVariable(QtCore.QObject):
-    valueChanged = QtCore.Signal(object) 
-
-    def __init__(self, initial=None):
-        super().__init__()
-        self._value = initial
-
-    def set(self, new_value):
-        """ Use this method to get emit the value changing and update the ROI count"""
-        if new_value != self._value:
-            self._value = new_value
-            self.valueChanged.emit(new_value)
-
-    def get(self):
-        return self._value
-
-    def __call__(self):
-        return self._value
-    
-    def reset(self):
-        self.set(0)
-
-    def __iadd__(self, amount):
-        if not isinstance(amount, (int, float)):
-            raise TypeError("Value must be numeric.")
-        self.set(self._value + amount)
-        return self
-    
-    def __radd__(self, other):
-        return other + self._value
-
-    def __add__(self, other):
-        return other + self._value
-        
-    def __isub__(self, amount):
-        if not isinstance(amount, (int, float)):
-            raise TypeError("Value must be numeric.")
-        self.set(self._value - amount)
-        return self
-    
-    def __str__(self):
-        return str(self._value)
-    
-    def __lt__(self, x):
-        return self._value < x
-    
-    def __gt__(self, x):
-        return self._value > x
-    
-    def __eq__(self, x):
-        return self._value == x
-
-
-class NormalizationSettings(QWidget):
-    # TODO
-    pass
-
-
-class SegmentationSettings(QWidget):
-    """ Container for gui settings. Validation is done automatically so any attributes can 
-    be acessed without concern.  
-    """
-    def __init__(self, font):
-        super().__init__()
-
-        # Put everything in a grid layout:
-        grid_layout = QGridLayout()
-        widget_container = QWidget()
-        widget_container.setLayout(grid_layout)
-        row = 0
-
-        ########################### Diameter ###########################
-        # TODO: Validate inputs
-        diam_qlabel = QLabel("diameter:")
-        diam_qlabel.setToolTip("diameter of cells in pixels. If not 30, image will be resized to this")
-        diam_qlabel.setFont(font)
-        grid_layout.addWidget(diam_qlabel, row, 0, 1, 2)
-        self.diameter_box = QLineEdit()
-        self.diameter_box.setToolTip("diameter of cells in pixels. If not blank, image will be resized relative to 30 pixel cell diameters")
-        self.diameter_box.setFont(font)
-        self.diameter_box.setFixedWidth(40)
-        self.diameter_box.setText(' ')
-        grid_layout.addWidget(self.diameter_box, row, 2, 1, 2)
-
-        row += 1
-
-        ########################### Flow threshold ###########################
-        # TODO: Validate inputs
-        flow_threshold_qlabel = QLabel("flow\nthreshold:")
-        flow_threshold_qlabel.setToolTip("threshold on flow error to accept a mask (set higher to get more cells, e.g. in range from (0.1, 3.0), OR set to 0.0 to turn off so no cells discarded);\n press enter to recompute if model already run")
-        flow_threshold_qlabel.setFont(font)
-        grid_layout.addWidget(flow_threshold_qlabel, row, 0, 1, 2)
-        self.flow_threshold_box = QLineEdit()
-        self.flow_threshold_box.setText("0.4")
-        self.flow_threshold_box.setFixedWidth(40)
-        self.flow_threshold_box.setFont(font)
-        grid_layout.addWidget(self.flow_threshold_box, row, 2, 1, 2)
-        self.flow_threshold_box.setToolTip("threshold on flow error to accept a mask (set higher to get more cells, e.g. in range from (0.1, 3.0), OR set to 0.0 to turn off so no cells discarded);\n press enter to recompute if model already run")
-        
-        ########################### Cellprob threshold ###########################
-        # TODO: Validate inputs
-        cellprob_qlabel = QLabel("cellprob\nthreshold:")
-        cellprob_qlabel.setToolTip("threshold on cellprob output to seed cell masks (set lower to include more pixels or higher to include fewer, e.g. in range from (-6, 6)); \n press enter to recompute if model already run")
-        cellprob_qlabel.setFont(font)
-        grid_layout.addWidget(cellprob_qlabel, row, 4, 1, 2)
-        self.cellprob_threshold_box = QLineEdit()
-        self.cellprob_threshold_box.setText("0.0")
-        self.cellprob_threshold_box.setFixedWidth(40)
-        self.cellprob_threshold_box.setFont(font)
-        self.cellprob_threshold_box.setToolTip("threshold on cellprob output to seed cell masks (set lower to include more pixels or higher to include fewer, e.g. in range from (-6, 6)); \n press enter to recompute if model already run")
-        grid_layout.addWidget(self.cellprob_threshold_box, row, 6, 1, 2)
-
-        row += 1
-
-        ########################### Norm percentiles ###########################
-        norm_percentiles_qlabel = QLabel("norm percentiles:")
-        norm_percentiles_qlabel.setToolTip("sets normalization percentiles for segmentation and denoising\n(pixels at lower percentile set to 0.0 and at upper set to 1.0 for network)")
-        norm_percentiles_qlabel.setFont(font)
-        grid_layout.addWidget(norm_percentiles_qlabel, row, 0, 1, 8)
-
-        row += 1
-        validator = QDoubleValidator(0.0, 100.0, 2)
-        validator.setNotation(QDoubleValidator.StandardNotation)
-
-        low_norm_qlabel = QLabel('lower:')
-        low_norm_qlabel.setToolTip("pixels at this percentile set to 0 (default 1.0)")
-        low_norm_qlabel.setFont(font)
-        grid_layout.addWidget(low_norm_qlabel, row, 0, 1, 2)
-        self.norm_percentile_low_box = QLineEdit()
-        self.norm_percentile_low_box.setText("1.0")
-        self.norm_percentile_low_box.setFont(font)
-        self.norm_percentile_low_box.setFixedWidth(40)
-        self.norm_percentile_low_box.setToolTip("pixels at this percentile set to 0 (default 1.0)")
-        self.norm_percentile_low_box.setValidator(validator)
-        self.norm_percentile_low_box.editingFinished.connect(self.validate_normalization_range)
-        grid_layout.addWidget(self.norm_percentile_low_box, row, 2, 1, 1)
-
-        high_norm_qlabel = QLabel('upper:')
-        high_norm_qlabel.setToolTip("pixels at this percentile set to 1 (default 99.0)")
-        high_norm_qlabel.setFont(font)
-        grid_layout.addWidget(high_norm_qlabel, row, 4, 1, 2)
-        self.norm_percentile_high_box = QLineEdit()
-        self.norm_percentile_high_box.setText("99.0")
-        self.norm_percentile_high_box.setFont(font)
-        self.norm_percentile_high_box.setFixedWidth(40)
-        self.norm_percentile_high_box.setToolTip("pixels at this percentile set to 1 (default 99.0)")
-        self.norm_percentile_high_box.setValidator(validator)
-        self.norm_percentile_high_box.editingFinished.connect(self.validate_normalization_range)
-        grid_layout.addWidget(self.norm_percentile_high_box, row, 6, 1, 2)
-
-        row += 1
-
-        ########################### niter ###########################
-        # TODO: change this to follow the same default logic as 'diameter' above
-        # TODO: input validation
-        niter_qlabel = QLabel("niter dynamics:")
-        niter_qlabel.setFont(font)
-        niter_qlabel.setToolTip("number of iterations for dynamics (0 uses default based on diameter); use 2000 for bacteria")
-        grid_layout.addWidget(niter_qlabel, row, 0, 1, 4)
-        self.niter_box = QLineEdit()
-        self.niter_box.setText("0")
-        self.niter_box.setFixedWidth(40)
-        self.niter_box.setFont(font)
-        self.niter_box.setToolTip("number of iterations for dynamics (0 uses default based on diameter); use 2000 for bacteria")
-        grid_layout.addWidget(self.niter_box, row, 4, 1, 2)
-
-        self.setLayout(grid_layout)
-
-    def validate_normalization_range(self):
-        low_text = self.norm_percentile_low_box.text()
-        high_text = self.norm_percentile_high_box.text()
-        
-        if not low_text or low_text.isspace():
-            self.norm_percentile_low_box.setText('1.0')
-            low_text = '1.0'
-        elif not high_text or high_text.isspace():
-            self.norm_percentile_high_box.setText('1.0')
-            high_text = '99.0'
-
-        low = float(low_text)
-        high = float(high_text)
-
-        if low >= high:
-            # Invalid: show error and mark fields
-            self.norm_percentile_low_box.setStyleSheet("border: 1px solid red;")
-            self.norm_percentile_high_box.setStyleSheet("border: 1px solid red;")
-        else:
-            # Valid: clear style
-            self.norm_percentile_low_box.setStyleSheet("")
-            self.norm_percentile_high_box.setStyleSheet("")
-
-    @property
-    def low_percentile(self):
-        """ Also validate the low input by returning 1.0 if text doesn't work """
-        low_text = self.norm_percentile_low_box.text()
-        if not low_text or low_text.isspace():
-            self.norm_percentile_low_box.setText('1.0')
-            low_text = '1.0'
-        return float(self.norm_percentile_low_box.text())
-    
-    @property
-    def high_percentile(self):
-        """ Also validate the high input by returning 99.0 if text doesn't work """
-        high_text = self.norm_percentile_high_box.text()
-        if not high_text or high_text.isspace():
-            self.norm_percentile_high_box.setText('99.0')
-            high_text = '99.0'
-        return float(self.norm_percentile_high_box.text())
-    
-    @property
-    def diameter(self):
-        """ Get the diameter from the diameter box, if box isn't a number return None"""
-        try:
-            d = float(self.diameter_box.text())
-        except ValueError:
-            d = None
-        return d 
-    
-    @property
-    def flow_threshold(self):
-        return float(self.flow_threshold_box.text())
-    
-    @property
-    def cellprob_threshold(self):
-        return float(self.cellprob_threshold_box.text())
-    
-    @property
-    def niter(self):
-        num = int(self.niter_box.text())
-        if num < 1:
-            self.niter_box.setText('200')
-            return 200
-        else:
-            return num
-
-
-
-class TrainWindow(QDialog):
-
-    def __init__(self, parent, model_strings):
-        super().__init__(parent)
-        self.setGeometry(100, 100, 900, 550)
-        self.setWindowTitle("train settings")
-        self.win = QWidget(self)
-        self.l0 = QGridLayout()
-        self.win.setLayout(self.l0)
-
-        yoff = 0
-        qlabel = QLabel("train model w/ images + _seg.npy in current folder >>")
-        qlabel.setFont(QtGui.QFont("Arial", 10, QtGui.QFont.Bold))
-
-        qlabel.setAlignment(QtCore.Qt.AlignVCenter)
-        self.l0.addWidget(qlabel, yoff, 0, 1, 2)
-
-        # choose initial model
-        yoff += 1
-        self.ModelChoose = QComboBox()
-        self.ModelChoose.addItems(model_strings)
-        self.ModelChoose.setFixedWidth(150)
-        self.ModelChoose.setCurrentIndex(parent.training_params["model_index"])
-        self.l0.addWidget(self.ModelChoose, yoff, 1, 1, 1)
-        qlabel = QLabel("initial model: ")
-        qlabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.l0.addWidget(qlabel, yoff, 0, 1, 1)
-
-        # choose parameters
-        labels = ["learning_rate", "weight_decay", "n_epochs", "model_name"]
-        self.edits = []
-        yoff += 1
-        for i, label in enumerate(labels):
-            qlabel = QLabel(label)
-            qlabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-            self.l0.addWidget(qlabel, i + yoff, 0, 1, 1)
-            self.edits.append(QLineEdit())
-            self.edits[-1].setText(str(parent.training_params[label]))
-            self.edits[-1].setFixedWidth(200)
-            self.l0.addWidget(self.edits[-1], i + yoff, 1, 1, 1)
-
-        yoff += len(labels)
-
-        yoff += 1
-        self.use_norm = QCheckBox(f"use restored/filtered image")
-        self.use_norm.setChecked(True)
-
-        yoff += 2
-        qlabel = QLabel(
-            "(to remove files, click cancel then remove \nfrom folder and reopen train window)"
-        )
-        self.l0.addWidget(qlabel, yoff, 0, 2, 4)
-
-        # click button
-        yoff += 3
-        QBtn = QDialogButtonBox.Ok | QDialogButtonBox.Cancel
-        self.buttonBox = QDialogButtonBox(QBtn)
-        self.buttonBox.accepted.connect(lambda: self.accept(parent))
-        self.buttonBox.rejected.connect(self.reject)
-        self.l0.addWidget(self.buttonBox, yoff, 0, 1, 4)
-
-        # list files in folder
-        qlabel = QLabel("filenames")
-        qlabel.setFont(QtGui.QFont("Arial", 8, QtGui.QFont.Bold))
-        self.l0.addWidget(qlabel, 0, 4, 1, 1)
-        qlabel = QLabel("# of masks")
-        qlabel.setFont(QtGui.QFont("Arial", 8, QtGui.QFont.Bold))
-        self.l0.addWidget(qlabel, 0, 5, 1, 1)
-
-        for i in range(10):
-            if i > len(parent.train_files) - 1:
-                break
-            elif i == 9 and len(parent.train_files) > 10:
-                label = "..."
-                nmasks = "..."
-            else:
-                label = os.path.split(parent.train_files[i])[-1]
-                nmasks = str(parent.train_labels[i].max())
-            qlabel = QLabel(label)
-            self.l0.addWidget(qlabel, i + 1, 4, 1, 1)
-            qlabel = QLabel(nmasks)
-            qlabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-            self.l0.addWidget(qlabel, i + 1, 5, 1, 1)
-
-    def accept(self, parent):
-        # set training params
-        parent.training_params = {
-            "model_index": self.ModelChoose.currentIndex(),
-            "learning_rate": float(self.edits[0].text()),
-            "weight_decay": float(self.edits[1].text()),
-            "n_epochs": int(self.edits[2].text()),
-            "model_name": self.edits[3].text(),
-            #"use_norm": True if self.use_norm.isChecked() else False,
-        }
-        self.done(1)
-
-
-class ExampleGUI(QDialog):
-
-    def __init__(self, parent=None):
-        super(ExampleGUI, self).__init__(parent)
-        self.setGeometry(100, 100, 1300, 900)
-        self.setWindowTitle("GUI layout")
-        self.win = QWidget(self)
-        layout = QGridLayout()
-        self.win.setLayout(layout)
-        guip_path = pathlib.Path.home().joinpath(".cellpose", "cellposeSAM_gui.png")
-        guip_path = str(guip_path.resolve())
-        pixmap = QPixmap(guip_path)
-        label = QLabel(self)
-        label.setPixmap(pixmap)
-        pixmap.scaled
-        layout.addWidget(label, 0, 0, 1, 1)
-
-
-class HelpWindow(QDialog):
-
-    def __init__(self, parent=None):
-        super(HelpWindow, self).__init__(parent)
-        self.setGeometry(100, 50, 700, 1000)
-        self.setWindowTitle("cellpose help")
-        self.win = QWidget(self)
-        layout = QGridLayout()
-        self.win.setLayout(layout)
-
-        text_file = pathlib.Path(__file__).parent.joinpath("guihelpwindowtext.html")
-        with open(str(text_file.resolve()), "r") as f:
-            text = f.read()
-
-        label = QLabel(text)
-        label.setFont(QtGui.QFont("Arial", 8))
-        label.setWordWrap(True)
-        layout.addWidget(label, 0, 0, 1, 1)
-        self.show()
-
-
-class TrainHelpWindow(QDialog):
-
-    def __init__(self, parent=None):
-        super(TrainHelpWindow, self).__init__(parent)
-        self.setGeometry(100, 50, 700, 300)
-        self.setWindowTitle("training instructions")
-        self.win = QWidget(self)
-        layout = QGridLayout()
-        self.win.setLayout(layout)
-
-        text_file = pathlib.Path(__file__).parent.joinpath(
-            "guitrainhelpwindowtext.html")
-        with open(str(text_file.resolve()), "r") as f:
-            text = f.read()
-
-        label = QLabel(text)
-        label.setFont(QtGui.QFont("Arial", 8))
-        label.setWordWrap(True)
-        layout.addWidget(label, 0, 0, 1, 1)
-        self.show()
-
-
-class ViewBoxNoRightDrag(pg.ViewBox):
-
-    def __init__(self, parent=None, border=None, lockAspect=False, enableMouse=True,
-                 invertY=False, enableMenu=True, name=None, invertX=False):
-        pg.ViewBox.__init__(self, None, border, lockAspect, enableMouse, invertY,
-                            enableMenu, name, invertX)
-        self.parent = parent
-        self.axHistoryPointer = -1
-
-    def keyPressEvent(self, ev):
-        """
-        This routine should capture key presses in the current view box.
-        The following events are implemented:
-        +/= : moves forward in the zooming stack (if it exists)
-        - : moves backward in the zooming stack (if it exists)
-
-        """
-        ev.accept()
-        if ev.text() == "-":
-            self.scaleBy([1.1, 1.1])
-        elif ev.text() in ["+", "="]:
-            self.scaleBy([0.9, 0.9])
-        else:
-            ev.ignore()
-
-
-class ImageDraw(pg.ImageItem):
-    """
-    **Bases:** :class:`GraphicsObject <pyqtgraph.GraphicsObject>`
-    GraphicsObject displaying an image. Optimized for rapid update (ie video display).
-    This item displays either a 2D numpy array (height, width) or
-    a 3D array (height, width, RGBa). This array is optionally scaled (see
-    :func:`setLevels <pyqtgraph.ImageItem.setLevels>`) and/or colored
-    with a lookup table (see :func:`setLookupTable <pyqtgraph.ImageItem.setLookupTable>`)
-    before being displayed.
-    ImageItem is frequently used in conjunction with
-    :class:`HistogramLUTItem <pyqtgraph.HistogramLUTItem>` or
-    :class:`HistogramLUTWidget <pyqtgraph.HistogramLUTWidget>` to provide a GUI
-    for controlling the levels and lookup table used to display the image.
-    """
-
-    sigImageChanged = QtCore.Signal()
-
-    def __init__(self, image=None, viewbox=None, parent=None, **kargs):
-        super(ImageDraw, self).__init__()
-        self.levels = np.array([0, 255])
-        self.lut = None
-        self.autoDownsample = False
-        self.axisOrder = "row-major"
-        self.removable = False
-
-        self.parent = parent
-        self.setDrawKernel(kernel_size=self.parent.brush_size)
-        self.parent.current_stroke = []
-        self.parent.in_stroke = False
-
-    def mouseClickEvent(self, ev):
-        if (self.parent.masksOn or
-                self.parent.outlinesOn) and not self.parent.removing_region:
-            is_right_click = ev.button() == QtCore.Qt.RightButton
-            if self.parent.loaded \
-                    and (is_right_click or ev.modifiers() & QtCore.Qt.ShiftModifier and not ev.double())\
-                    and not self.parent.deleting_multiple:
-                if not self.parent.in_stroke:
-                    ev.accept()
-                    self.create_start(ev.pos())
-                    self.parent.stroke_appended = False
-                    self.parent.in_stroke = True
-                    self.drawAt(ev.pos(), ev)
-                else:
-                    ev.accept()
-                    self.end_stroke()
-                    self.parent.in_stroke = False
-            elif not self.parent.in_stroke:
-                y, x = int(ev.pos().y()), int(ev.pos().x())
-                if y >= 0 and y < self.parent.Ly and x >= 0 and x < self.parent.Lx:
-                    if ev.button() == QtCore.Qt.LeftButton and not ev.double():
-                        idx = self.parent.cellpix[self.parent.currentZ][y, x]
-                        if idx > 0:
-                            if ev.modifiers() & QtCore.Qt.ControlModifier:
-                                # delete mask selected
-                                self.parent.remove_cell(idx)
-                            elif ev.modifiers() & QtCore.Qt.AltModifier:
-                                self.parent.merge_cells(idx)
-                            elif self.parent.masksOn and not self.parent.deleting_multiple:
-                                self.parent.unselect_cell()
-                                self.parent.select_cell(idx)
-                            elif self.parent.deleting_multiple:
-                                if idx in self.parent.removing_cells_list:
-                                    self.parent.unselect_cell_multi(idx)
-                                    self.parent.removing_cells_list.remove(idx)
-                                else:
-                                    self.parent.select_cell_multi(idx)
-                                    self.parent.removing_cells_list.append(idx)
-
-                        elif self.parent.masksOn and not self.parent.deleting_multiple:
-                            self.parent.unselect_cell()
-
-    def mouseDragEvent(self, ev):
-        ev.ignore()
-        return
-
-    def hoverEvent(self, ev):
-        if self.parent.in_stroke:
-            if self.parent.in_stroke:
-                # continue stroke if not at start
-                self.drawAt(ev.pos())
-                if self.is_at_start(ev.pos()):
-                    self.end_stroke()
-        else:
-            ev.acceptClicks(QtCore.Qt.RightButton)
-
-    def create_start(self, pos):
-        self.scatter = pg.ScatterPlotItem([pos.x()], [pos.y()], pxMode=False,
-                                          pen=pg.mkPen(color=(255, 0, 0),
-                                                       width=self.parent.brush_size),
-                                          size=max(3 * 2,
-                                                   self.parent.brush_size * 1.8 * 2),
-                                          brush=None)
-        self.parent.p0.addItem(self.scatter)
-
-    def is_at_start(self, pos):
-        thresh_out = max(6, self.parent.brush_size * 3)
-        thresh_in = max(3, self.parent.brush_size * 1.8)
-        # first check if you ever left the start
-        if len(self.parent.current_stroke) > 3:
-            stroke = np.array(self.parent.current_stroke)
-            dist = (((stroke[1:, 1:] -
-                      stroke[:1, 1:][np.newaxis, :, :])**2).sum(axis=-1))**0.5
-            dist = dist.flatten()
-            has_left = (dist > thresh_out).nonzero()[0]
-            if len(has_left) > 0:
-                first_left = np.sort(has_left)[0]
-                has_returned = (dist[max(4, first_left + 1):] < thresh_in).sum()
-                if has_returned > 0:
-                    return True
-                else:
-                    return False
-            else:
-                return False
-
-    def end_stroke(self):
-        self.parent.p0.removeItem(self.scatter)
-        if not self.parent.stroke_appended:
-            self.parent.strokes.append(self.parent.current_stroke)
-            self.parent.stroke_appended = True
-            self.parent.current_stroke = np.array(self.parent.current_stroke)
-            ioutline = self.parent.current_stroke[:, 3] == 1
-            self.parent.current_point_set.append(
-                list(self.parent.current_stroke[ioutline]))
-            self.parent.current_stroke = []
-            if self.parent.autosave:
-                self.parent.add_set()
-        if len(self.parent.current_point_set) and len(
-                self.parent.current_point_set[0]) > 0 and self.parent.autosave:
-            self.parent.add_set()
-        self.parent.in_stroke = False
-
-    def tabletEvent(self, ev):
-        pass
-
-    def drawAt(self, pos, ev=None):
-        mask = self.strokemask
-        stroke = self.parent.current_stroke
-        pos = [int(pos.y()), int(pos.x())]
-        dk = self.drawKernel
-        kc = self.drawKernelCenter
-        sx = [0, dk.shape[0]]
-        sy = [0, dk.shape[1]]
-        tx = [pos[0] - kc[0], pos[0] - kc[0] + dk.shape[0]]
-        ty = [pos[1] - kc[1], pos[1] - kc[1] + dk.shape[1]]
-        kcent = kc.copy()
-        if tx[0] <= 0:
-            sx[0] = 0
-            sx[1] = kc[0] + 1
-            tx = sx
-            kcent[0] = 0
-        if ty[0] <= 0:
-            sy[0] = 0
-            sy[1] = kc[1] + 1
-            ty = sy
-            kcent[1] = 0
-        if tx[1] >= self.parent.Ly - 1:
-            sx[0] = dk.shape[0] - kc[0] - 1
-            sx[1] = dk.shape[0]
-            tx[0] = self.parent.Ly - kc[0] - 1
-            tx[1] = self.parent.Ly
-            kcent[0] = tx[1] - tx[0] - 1
-        if ty[1] >= self.parent.Lx - 1:
-            sy[0] = dk.shape[1] - kc[1] - 1
-            sy[1] = dk.shape[1]
-            ty[0] = self.parent.Lx - kc[1] - 1
-            ty[1] = self.parent.Lx
-            kcent[1] = ty[1] - ty[0] - 1
-
-        ts = (slice(tx[0], tx[1]), slice(ty[0], ty[1]))
-        ss = (slice(sx[0], sx[1]), slice(sy[0], sy[1]))
-        self.image[ts] = mask[ss]
-
-        for ky, y in enumerate(np.arange(ty[0], ty[1], 1, int)):
-            for kx, x in enumerate(np.arange(tx[0], tx[1], 1, int)):
-                iscent = np.logical_and(kx == kcent[0], ky == kcent[1])
-                stroke.append([self.parent.currentZ, x, y, iscent])
-        self.updateImage()
-
-    def setDrawKernel(self, kernel_size=3):
-        bs = kernel_size
-        kernel = np.ones((bs, bs), np.uint8)
-        self.drawKernel = kernel
-        self.drawKernelCenter = [
-            int(np.floor(kernel.shape[0] / 2)),
-            int(np.floor(kernel.shape[1] / 2))
-        ]
-        onmask = 255 * kernel[:, :, np.newaxis]
-        offmask = np.zeros((bs, bs, 1))
-        opamask = 100 * kernel[:, :, np.newaxis]
-        self.redmask = np.concatenate((onmask, offmask, offmask, onmask), axis=-1)
-        self.strokemask = np.concatenate((onmask, offmask, onmask, opamask), axis=-1)

models/seg_post_model/cellpose/gui/guitrainhelpwindowtext.html

@@ -1,25 +0,0 @@
-<qt>
-    Check out this <a href="https://youtu.be/3Y1VKcxjNy4">video</a> to learn the process.
-    <ol>
-        <li>Drag and drop an image from a folder of images with a similar style (like similar cell types).</li>
-        <li>Run the built-in models on one of the images using the "model zoo" and find the one that works best for your
-            data. Make sure that if you have a nuclear channel you have selected it for CHAN2.
-        </li>
-        <li>Fix the labelling by drawing new ROIs (right-click) and deleting incorrect ones (CTRL+click). The GUI
-            autosaves any manual changes (but does not autosave after running the model, for that click CTRL+S). The
-            segmentation is saved in a "_seg.npy" file.
-        </li>
-        <li> Go to the "Models" menu in the File bar at the top and click "Train new model..." or use shortcut CTRL+T.
-        </li>
-        <li> Choose the pretrained model to start the training from (the model you used in #2), and type in the model
-            name that you want to use. The other parameters should work well in general for most data types. Then click
-            OK.
-        </li>
-        <li> The model will train (much faster if you have a GPU) and then auto-run on the next image in the folder.
-            Next you can repeat #3-#5 as many times as is necessary.
-        </li>
-        <li> The trained model is available to use in the future in the GUI in the "custom model" section and is saved
-            in your image folder.
-        </li>
-    </ol>
-</qt>

models/seg_post_model/cellpose/gui/io.py

@@ -1,634 +0,0 @@
-"""
-Copyright © 2025 Howard Hughes Medical Institute, Authored by Carsen Stringer , Michael Rariden and Marius Pachitariu.
-"""
-import os, gc
-import numpy as np
-import cv2
-import fastremap
-
-from ..io import imread, imread_2D, imread_3D, imsave, outlines_to_text, add_model, remove_model, save_rois
-from ..models import normalize_default, MODEL_DIR, MODEL_LIST_PATH, get_user_models
-from ..utils import masks_to_outlines, outlines_list
-
-try:
-    import qtpy
-    from qtpy.QtWidgets import QFileDialog
-    GUI = True
-except:
-    GUI = False
-
-try:
-    import matplotlib.pyplot as plt
-    MATPLOTLIB = True
-except:
-    MATPLOTLIB = False
-
-
-def _init_model_list(parent):
-    MODEL_DIR.mkdir(parents=True, exist_ok=True)
-    parent.model_list_path = MODEL_LIST_PATH
-    parent.model_strings = get_user_models()
-
-
-def _add_model(parent, filename=None, load_model=True):
-    if filename is None:
-        name = QFileDialog.getOpenFileName(parent, "Add model to GUI")
-        filename = name[0]
-    add_model(filename)
-    fname = os.path.split(filename)[-1]
-    parent.ModelChooseC.addItems([fname])
-    parent.model_strings.append(fname)
-
-    for ind, model_string in enumerate(parent.model_strings[:-1]):
-        if model_string == fname:
-            _remove_model(parent, ind=ind + 1, verbose=False)
-
-    parent.ModelChooseC.setCurrentIndex(len(parent.model_strings))
-    if load_model:
-        parent.model_choose(custom=True)
-
-
-def _remove_model(parent, ind=None, verbose=True):
-    if ind is None:
-        ind = parent.ModelChooseC.currentIndex()
-    if ind > 0:
-        ind -= 1
-        parent.ModelChooseC.removeItem(ind + 1)
-        del parent.model_strings[ind]
-        # remove model from txt path
-        modelstr = parent.ModelChooseC.currentText()
-        remove_model(modelstr)
-        if len(parent.model_strings) > 0:
-            parent.ModelChooseC.setCurrentIndex(len(parent.model_strings))
-        else:
-            parent.ModelChooseC.setCurrentIndex(0)
-    else:
-        print("ERROR: no model selected to delete")
-
-
-def _get_train_set(image_names):
-    """ get training data and labels for images in current folder image_names"""
-    train_data, train_labels, train_files = [], [], []
-    restore = None
-    normalize_params = normalize_default
-    for image_name_full in image_names:
-        image_name = os.path.splitext(image_name_full)[0]
-        label_name = None
-        if os.path.exists(image_name + "_seg.npy"):
-            dat = np.load(image_name + "_seg.npy", allow_pickle=True).item()
-            masks = dat["masks"].squeeze()
-            if masks.ndim == 2:
-                fastremap.renumber(masks, in_place=True)
-                label_name = image_name + "_seg.npy"
-            else:
-                print(f"GUI_INFO: _seg.npy found for {image_name} but masks.ndim!=2")
-            if "img_restore" in dat:
-                data = dat["img_restore"].squeeze()
-                restore = dat["restore"]
-            else:
-                data = imread(image_name_full)
-            normalize_params = dat[
-                "normalize_params"] if "normalize_params" in dat else normalize_default
-        if label_name is not None:
-            train_files.append(image_name_full)
-            train_data.append(data)
-            train_labels.append(masks)
-    if restore:
-        print(f"GUI_INFO: using {restore} images (dat['img_restore'])")
-    return train_data, train_labels, train_files, restore, normalize_params
-
-
-def _load_image(parent, filename=None, load_seg=True, load_3D=False):
-    """ load image with filename; if None, open QFileDialog
-    if image is grey change view to default to grey scale 
-    """
-
-    if parent.load_3D:
-        load_3D = True
-
-    if filename is None:
-        name = QFileDialog.getOpenFileName(parent, "Load image")
-        filename = name[0]
-        if filename == "":
-            return
-    manual_file = os.path.splitext(filename)[0] + "_seg.npy"
-    load_mask = False
-    if load_seg:
-        if os.path.isfile(manual_file) and not parent.autoloadMasks.isChecked():
-            if filename is not None:
-                image = (imread_2D(filename) if not load_3D else 
-                         imread_3D(filename))
-            else:
-                image = None
-            _load_seg(parent, manual_file, image=image, image_file=filename,
-                      load_3D=load_3D)
-            return
-        elif parent.autoloadMasks.isChecked():
-            mask_file = os.path.splitext(filename)[0] + "_masks" + os.path.splitext(
-                filename)[-1]
-            mask_file = os.path.splitext(filename)[
-                0] + "_masks.tif" if not os.path.isfile(mask_file) else mask_file
-            load_mask = True if os.path.isfile(mask_file) else False
-    try:
-        print(f"GUI_INFO: loading image: {filename}")
-        if not load_3D:
-            image = imread_2D(filename)
-        else:
-            image = imread_3D(filename)
-        parent.loaded = True
-    except Exception as e:
-        print("ERROR: images not compatible")
-        print(f"ERROR: {e}")
-
-    if parent.loaded:
-        parent.reset()
-        parent.filename = filename
-        filename = os.path.split(parent.filename)[-1]
-        _initialize_images(parent, image, load_3D=load_3D)
-        parent.loaded = True
-        parent.enable_buttons()
-        if load_mask:
-            _load_masks(parent, filename=mask_file)
-
-    # check if gray and adjust viewer:
-    if len(np.unique(image[..., 1:])) == 1:
-        parent.color = 4
-        parent.RGBDropDown.setCurrentIndex(4) # gray
-        parent.update_plot()
-
-        
-def _initialize_images(parent, image, load_3D=False):
-    """ format image for GUI
-
-    assumes image is Z x W x H x C
-
-    """
-    load_3D = parent.load_3D if load_3D is False else load_3D
-
-    parent.stack = image
-    print(f"GUI_INFO: image shape: {image.shape}")
-    if load_3D:
-        parent.NZ = len(parent.stack)
-        parent.scroll.setMaximum(parent.NZ - 1)
-    else:
-        parent.NZ = 1
-        parent.stack = parent.stack[np.newaxis, ...]
-
-    img_min = image.min()
-    img_max = image.max()
-    parent.stack = parent.stack.astype(np.float32)
-    parent.stack -= img_min
-    if img_max > img_min + 1e-3:
-        parent.stack /= (img_max - img_min)
-    parent.stack *= 255
-
-    if load_3D:
-        print("GUI_INFO: converted to float and normalized values to 0.0->255.0")
-
-    del image
-    gc.collect()
-
-    parent.imask = 0
-    parent.Ly, parent.Lx = parent.stack.shape[-3:-1]
-    parent.Ly0, parent.Lx0 = parent.stack.shape[-3:-1]
-    parent.layerz = 255 * np.ones((parent.Ly, parent.Lx, 4), "uint8")
-    if hasattr(parent, "stack_filtered"):
-        parent.Lyr, parent.Lxr = parent.stack_filtered.shape[-3:-1]
-    elif parent.restore and "upsample" in parent.restore:
-        parent.Lyr, parent.Lxr = int(parent.Ly * parent.ratio), int(parent.Lx *
-                                                                    parent.ratio)
-    else:
-        parent.Lyr, parent.Lxr = parent.Ly, parent.Lx
-    parent.clear_all()
-
-    if not hasattr(parent, "stack_filtered") and parent.restore:
-        print("GUI_INFO: no 'img_restore' found, applying current settings")
-        parent.compute_restore()
-
-    if parent.autobtn.isChecked():
-        if parent.restore is None or parent.restore != "filter":
-            print(
-                "GUI_INFO: normalization checked: computing saturation levels (and optionally filtered image)"
-            )
-            parent.compute_saturation()
-    # elif len(parent.saturation) != parent.NZ:
-    #     parent.saturation = []
-    #     for r in range(3):
-    #         parent.saturation.append([])
-    #         for n in range(parent.NZ):
-    #             parent.saturation[-1].append([0, 255])
-    #         parent.sliders[r].setValue([0, 255])
-    parent.compute_scale()
-    parent.track_changes = []
-
-    if load_3D:
-        parent.currentZ = int(np.floor(parent.NZ / 2))
-        parent.scroll.setValue(parent.currentZ)
-        parent.zpos.setText(str(parent.currentZ))
-    else:
-        parent.currentZ = 0
-
-
-def _load_seg(parent, filename=None, image=None, image_file=None, load_3D=False):
-    """ load *_seg.npy with filename; if None, open QFileDialog """
-    if filename is None:
-        name = QFileDialog.getOpenFileName(parent, "Load labelled data", filter="*.npy")
-        filename = name[0]
-    try:
-        dat = np.load(filename, allow_pickle=True).item()
-        # check if there are keys in filename
-        dat["outlines"]
-        parent.loaded = True
-    except:
-        parent.loaded = False
-        print("ERROR: not NPY")
-        return
-
-    parent.reset()
-    if image is None:
-        found_image = False
-        if "filename" in dat:
-            parent.filename = dat["filename"]
-            if os.path.isfile(parent.filename):
-                parent.filename = dat["filename"]
-                found_image = True
-            else:
-                imgname = os.path.split(parent.filename)[1]
-                root = os.path.split(filename)[0]
-                parent.filename = root + "/" + imgname
-                if os.path.isfile(parent.filename):
-                    found_image = True
-        if found_image:
-            try:
-                print(parent.filename)
-                image = (imread_2D(parent.filename) if not load_3D else 
-                         imread_3D(parent.filename))
-            except:
-                parent.loaded = False
-                found_image = False
-                print("ERROR: cannot find image file, loading from npy")
-        if not found_image:
-            parent.filename = filename[:-8]
-            print(parent.filename)
-            if "img" in dat:
-                image = dat["img"]
-            else:
-                print("ERROR: no image file found and no image in npy")
-                return
-    else:
-        parent.filename = image_file
-
-    parent.restore = None
-    parent.ratio = 1.
-
-    if "normalize_params" in dat:
-        parent.set_normalize_params(dat["normalize_params"])
-
-    _initialize_images(parent, image, load_3D=load_3D)
-    print(parent.stack.shape)
-
-    if "outlines" in dat:
-        if isinstance(dat["outlines"], list):
-            # old way of saving files
-            dat["outlines"] = dat["outlines"][::-1]
-            for k, outline in enumerate(dat["outlines"]):
-                if "colors" in dat:
-                    color = dat["colors"][k]
-                else:
-                    col_rand = np.random.randint(1000)
-                    color = parent.colormap[col_rand, :3]
-                median = parent.add_mask(points=outline, color=color)
-                if median is not None:
-                    parent.cellcolors = np.append(parent.cellcolors,
-                                                  color[np.newaxis, :], axis=0)
-                    parent.ncells += 1
-        else:
-            if dat["masks"].min() == -1:
-                dat["masks"] += 1
-                dat["outlines"] += 1
-            parent.ncells.set(dat["masks"].max())
-            if "colors" in dat and len(dat["colors"]) == dat["masks"].max():
-                colors = dat["colors"]
-            else:
-                colors = parent.colormap[:parent.ncells.get(), :3]
-
-            _masks_to_gui(parent, dat["masks"], outlines=dat["outlines"], colors=colors)
-
-            parent.draw_layer()
-
-        if "manual_changes" in dat:
-            parent.track_changes = dat["manual_changes"]
-            print("GUI_INFO: loaded in previous changes")
-        if "zdraw" in dat:
-            parent.zdraw = dat["zdraw"]
-        else:
-            parent.zdraw = [None for n in range(parent.ncells.get())]
-        parent.loaded = True
-    else:
-        parent.clear_all()
-
-    parent.ismanual = np.zeros(parent.ncells.get(), bool)
-    if "ismanual" in dat:
-        if len(dat["ismanual"]) == parent.ncells:
-            parent.ismanual = dat["ismanual"]
-
-    if "current_channel" in dat:
-        parent.color = (dat["current_channel"] + 2) % 5
-        parent.RGBDropDown.setCurrentIndex(parent.color)
-
-    if "flows" in dat:
-        parent.flows = dat["flows"]
-        try:
-            if parent.flows[0].shape[-3] != dat["masks"].shape[-2]:
-                Ly, Lx = dat["masks"].shape[-2:]
-                for i in range(len(parent.flows)):
-                    parent.flows[i] = cv2.resize(
-                        parent.flows[i].squeeze(), (Lx, Ly),
-                        interpolation=cv2.INTER_NEAREST)[np.newaxis, ...]
-            if parent.NZ == 1:
-                parent.recompute_masks = True
-            else:
-                parent.recompute_masks = False
-
-        except:
-            try:
-                if len(parent.flows[0]) > 0:
-                    parent.flows = parent.flows[0]
-            except:
-                parent.flows = [[], [], [], [], [[]]]
-            parent.recompute_masks = False
-
-    parent.enable_buttons()
-    parent.update_layer()
-    del dat
-    gc.collect()
-
-
-def _load_masks(parent, filename=None):
-    """ load zeros-based masks (0=no cell, 1=cell 1, ...) """
-    if filename is None:
-        name = QFileDialog.getOpenFileName(parent, "Load masks (PNG or TIFF)")
-        filename = name[0]
-    print(f"GUI_INFO: loading masks: {filename}")
-    masks = imread(filename)
-    outlines = None
-    if masks.ndim > 3:
-        # Z x nchannels x Ly x Lx
-        if masks.shape[-1] > 5:
-            parent.flows = list(np.transpose(masks[:, :, :, 2:], (3, 0, 1, 2)))
-            outlines = masks[..., 1]
-            masks = masks[..., 0]
-        else:
-            parent.flows = list(np.transpose(masks[:, :, :, 1:], (3, 0, 1, 2)))
-            masks = masks[..., 0]
-    elif masks.ndim == 3:
-        if masks.shape[-1] < 5:
-            masks = masks[np.newaxis, :, :, 0]
-    elif masks.ndim < 3:
-        masks = masks[np.newaxis, :, :]
-    # masks should be Z x Ly x Lx
-    if masks.shape[0] != parent.NZ:
-        print("ERROR: masks are not same depth (number of planes) as image stack")
-        return
-
-    _masks_to_gui(parent, masks, outlines)
-    if parent.ncells > 0:
-        parent.draw_layer()
-        parent.toggle_mask_ops()
-    del masks
-    gc.collect()
-    parent.update_layer()
-    parent.update_plot()
-
-
-def _masks_to_gui(parent, masks, outlines=None, colors=None):
-    """ masks loaded into GUI """
-    # get unique values
-    shape = masks.shape
-    if len(fastremap.unique(masks)) != masks.max() + 1:
-        print("GUI_INFO: renumbering masks")
-        fastremap.renumber(masks, in_place=True)
-        outlines = None
-        masks = masks.reshape(shape)
-    if masks.ndim == 2:
-        outlines = None
-    masks = masks.astype(np.uint16) if masks.max() < 2**16 - 1 else masks.astype(
-        np.uint32)
-    if parent.restore and "upsample" in parent.restore:
-        parent.cellpix_resize = masks.copy()
-        parent.cellpix = parent.cellpix_resize.copy()
-        parent.cellpix_orig = cv2.resize(
-            masks.squeeze(), (parent.Lx0, parent.Ly0),
-            interpolation=cv2.INTER_NEAREST)[np.newaxis, :, :]
-        parent.resize = True
-    else:
-        parent.cellpix = masks
-    if parent.cellpix.ndim == 2:
-        parent.cellpix = parent.cellpix[np.newaxis, :, :]
-        if parent.restore and "upsample" in parent.restore:
-            if parent.cellpix_resize.ndim == 2:
-                parent.cellpix_resize = parent.cellpix_resize[np.newaxis, :, :]
-            if parent.cellpix_orig.ndim == 2:
-                parent.cellpix_orig = parent.cellpix_orig[np.newaxis, :, :]
-
-    print(f"GUI_INFO: {masks.max()} masks found")
-
-    # get outlines
-    if outlines is None:  # parent.outlinesOn
-        parent.outpix = np.zeros_like(parent.cellpix)
-        if parent.restore and "upsample" in parent.restore:
-            parent.outpix_orig = np.zeros_like(parent.cellpix_orig)
-        for z in range(parent.NZ):
-            outlines = masks_to_outlines(parent.cellpix[z])
-            parent.outpix[z] = outlines * parent.cellpix[z]
-            if parent.restore and "upsample" in parent.restore:
-                outlines = masks_to_outlines(parent.cellpix_orig[z])
-                parent.outpix_orig[z] = outlines * parent.cellpix_orig[z]
-            if z % 50 == 0 and parent.NZ > 1:
-                print("GUI_INFO: plane %d outlines processed" % z)
-        if parent.restore and "upsample" in parent.restore:
-            parent.outpix_resize = parent.outpix.copy()
-    else:
-        parent.outpix = outlines
-        if parent.restore and "upsample" in parent.restore:
-            parent.outpix_resize = parent.outpix.copy()
-            parent.outpix_orig = np.zeros_like(parent.cellpix_orig)
-            for z in range(parent.NZ):
-                outlines = masks_to_outlines(parent.cellpix_orig[z])
-                parent.outpix_orig[z] = outlines * parent.cellpix_orig[z]
-                if z % 50 == 0 and parent.NZ > 1:
-                    print("GUI_INFO: plane %d outlines processed" % z)
-
-    if parent.outpix.ndim == 2:
-        parent.outpix = parent.outpix[np.newaxis, :, :]
-        if parent.restore and "upsample" in parent.restore:
-            if parent.outpix_resize.ndim == 2:
-                parent.outpix_resize = parent.outpix_resize[np.newaxis, :, :]
-            if parent.outpix_orig.ndim == 2:
-                parent.outpix_orig = parent.outpix_orig[np.newaxis, :, :]
-
-    parent.ncells.set(parent.cellpix.max())
-    colors = parent.colormap[:parent.ncells.get(), :3] if colors is None else colors
-    print("GUI_INFO: creating cellcolors and drawing masks")
-    parent.cellcolors = np.concatenate((np.array([[255, 255, 255]]), colors),
-                                       axis=0).astype(np.uint8)
-    if parent.ncells > 0:
-        parent.draw_layer()
-        parent.toggle_mask_ops()
-    parent.ismanual = np.zeros(parent.ncells.get(), bool)
-    parent.zdraw = list(-1 * np.ones(parent.ncells.get(), np.int16))
-
-    if hasattr(parent, "stack_filtered"):
-        parent.ViewDropDown.setCurrentIndex(parent.ViewDropDown.count() - 1)
-        print("set denoised/filtered view")
-    else:
-        parent.ViewDropDown.setCurrentIndex(0)
-
-
-def _save_png(parent):
-    """ save masks to png or tiff (if 3D) """
-    filename = parent.filename
-    base = os.path.splitext(filename)[0]
-    if parent.NZ == 1:
-        if parent.cellpix[0].max() > 65534:
-            print("GUI_INFO: saving 2D masks to tif (too many masks for PNG)")
-            imsave(base + "_cp_masks.tif", parent.cellpix[0])
-        else:
-            print("GUI_INFO: saving 2D masks to png")
-            imsave(base + "_cp_masks.png", parent.cellpix[0].astype(np.uint16))
-    else:
-        print("GUI_INFO: saving 3D masks to tiff")
-        imsave(base + "_cp_masks.tif", parent.cellpix)
-
-
-def _save_flows(parent):
-    """ save flows and cellprob to tiff """
-    filename = parent.filename
-    base = os.path.splitext(filename)[0]
-    print("GUI_INFO: saving flows and cellprob to tiff")
-    if len(parent.flows) > 0:
-        imsave(base + "_cp_cellprob.tif", parent.flows[1])
-        for i in range(3):
-            imsave(base + f"_cp_flows_{i}.tif", parent.flows[0][..., i])
-        if len(parent.flows) > 2:
-            imsave(base + "_cp_flows.tif", parent.flows[2])
-        print("GUI_INFO: saved flows and cellprob")
-    else:
-        print("ERROR: no flows or cellprob found")
-
-
-def _save_rois(parent):
-    """ save masks as rois in .zip file for ImageJ """
-    filename = parent.filename
-    if parent.NZ == 1:
-        print(
-            f"GUI_INFO: saving {parent.cellpix[0].max()} ImageJ ROIs to .zip archive.")
-        save_rois(parent.cellpix[0], parent.filename)
-    else:
-        print("ERROR: cannot save 3D outlines")
-
-
-def _save_outlines(parent):
-    filename = parent.filename
-    base = os.path.splitext(filename)[0]
-    if parent.NZ == 1:
-        print(
-            "GUI_INFO: saving 2D outlines to text file, see docs for info to load into ImageJ"
-        )
-        outlines = outlines_list(parent.cellpix[0])
-        outlines_to_text(base, outlines)
-    else:
-        print("ERROR: cannot save 3D outlines")
-
-
-def _save_sets_with_check(parent):
-    """ Save masks and update *_seg.npy file. Use this function when saving should be optional
-     based on the disableAutosave checkbox. Otherwise, use _save_sets """
-    if not parent.disableAutosave.isChecked():
-        _save_sets(parent)
-
-
-def _save_sets(parent):
-    """ save masks to *_seg.npy. This function should be used when saving
-    is forced, e.g. when clicking the save button. Otherwise, use _save_sets_with_check
-    """
-    filename = parent.filename
-    base = os.path.splitext(filename)[0]
-    flow_threshold = parent.segmentation_settings.flow_threshold
-    cellprob_threshold = parent.segmentation_settings.cellprob_threshold
-
-    if parent.NZ > 1:
-        dat = {
-            "outlines":
-                parent.outpix,
-            "colors":
-                parent.cellcolors[1:],
-            "masks":
-                parent.cellpix,
-            "current_channel": (parent.color - 2) % 5,
-            "filename":
-                parent.filename,
-            "flows":
-                parent.flows,
-            "zdraw":
-                parent.zdraw,
-            "model_path":
-                parent.current_model_path
-                if hasattr(parent, "current_model_path") else 0,
-            "flow_threshold":
-                flow_threshold,
-            "cellprob_threshold":
-                cellprob_threshold,
-            "normalize_params":
-                parent.get_normalize_params(),
-            "restore":
-                parent.restore,
-            "ratio":
-                parent.ratio,
-            "diameter":
-                parent.segmentation_settings.diameter
-        }
-        if parent.restore is not None:
-            dat["img_restore"] = parent.stack_filtered
-    else:
-        dat = {
-            "outlines":
-                parent.outpix.squeeze() if parent.restore is None or
-                not "upsample" in parent.restore else parent.outpix_resize.squeeze(),
-            "colors":
-                parent.cellcolors[1:],
-            "masks":
-                parent.cellpix.squeeze() if parent.restore is None or
-                not "upsample" in parent.restore else parent.cellpix_resize.squeeze(),
-            "filename":
-                parent.filename,
-            "flows":
-                parent.flows,
-            "ismanual":
-                parent.ismanual,
-            "manual_changes":
-                parent.track_changes,
-            "model_path":
-                parent.current_model_path
-                if hasattr(parent, "current_model_path") else 0,
-            "flow_threshold":
-                flow_threshold,
-            "cellprob_threshold":
-                cellprob_threshold,
-            "normalize_params":
-                parent.get_normalize_params(),
-            "restore":
-                parent.restore,
-            "ratio":
-                parent.ratio,
-            "diameter":
-                parent.segmentation_settings.diameter
-        }
-        if parent.restore is not None:
-            dat["img_restore"] = parent.stack_filtered
-    try:
-        np.save(base + "_seg.npy", dat)
-        print("GUI_INFO: %d ROIs saved to %s" % (parent.ncells.get(), base + "_seg.npy"))
-    except Exception as e:
-        print(f"ERROR: {e}")
-    del dat

models/seg_post_model/cellpose/gui/make_train.py

@@ -1,107 +0,0 @@
-import os, argparse
-import numpy as np
-from cellpose import io, transforms
-
-
-def main():
-    parser = argparse.ArgumentParser(description='Make slices of XYZ image data for training. Assumes image is ZXYC unless specified otherwise using --channel_axis and --z_axis')
-
-    input_img_args = parser.add_argument_group("input image arguments")
-    input_img_args.add_argument('--dir', default=[], type=str,
-                                help='folder containing data to run or train on.')
-    input_img_args.add_argument(
-        '--image_path', default=[], type=str, help=
-        'if given and --dir not given, run on single image instead of folder (cannot train with this option)'
-    )
-    input_img_args.add_argument(
-        '--look_one_level_down', action='store_true',
-        help='run processing on all subdirectories of current folder')
-    input_img_args.add_argument('--img_filter', default=[], type=str,
-                                help='end string for images to run on')
-    input_img_args.add_argument(
-        '--channel_axis', default=-1, type=int,
-        help='axis of image which corresponds to image channels')
-    input_img_args.add_argument('--z_axis', default=0, type=int,
-                                help='axis of image which corresponds to Z dimension')
-    input_img_args.add_argument(
-        '--chan', default=0, type=int, help=
-        'Deprecated')
-    input_img_args.add_argument(
-        '--chan2', default=0, type=int, help=
-        'Deprecated'
-    )
-    input_img_args.add_argument('--invert', action='store_true',
-                                help='invert grayscale channel')
-    input_img_args.add_argument(
-        '--all_channels', action='store_true', help=
-        'deprecated')
-    input_img_args.add_argument("--anisotropy", required=False, default=1.0, type=float,
-                                help="anisotropy of volume in 3D")
-    
-
-    # algorithm settings
-    algorithm_args = parser.add_argument_group("algorithm arguments")
-    algorithm_args.add_argument('--sharpen_radius', required=False, default=0.0,
-                                type=float, help='high-pass filtering radius. Default: %(default)s')
-    algorithm_args.add_argument('--tile_norm', required=False, default=0, type=int,
-                                help='tile normalization block size. Default: %(default)s')
-    algorithm_args.add_argument('--nimg_per_tif', required=False, default=10, type=int,
-                                help='number of crops in XY to save per tiff. Default: %(default)s')
-    algorithm_args.add_argument('--crop_size', required=False, default=512, type=int,
-                                help='size of random crop to save. Default: %(default)s')
-
-    args = parser.parse_args()
-
-    # find images
-    if len(args.img_filter) > 0:
-        imf = args.img_filter
-    else:
-        imf = None
-
-    if len(args.dir) > 0:
-        image_names = io.get_image_files(args.dir, "_masks", imf=imf,
-                                     look_one_level_down=args.look_one_level_down)
-        dirname = args.dir
-    else:
-        if os.path.exists(args.image_path):
-            image_names = [args.image_path]
-            dirname = os.path.split(args.image_path)[0]
-        else:
-            raise ValueError(f"ERROR: no file found at {args.image_path}")
-        
-    np.random.seed(0)
-    nimg_per_tif = args.nimg_per_tif
-    crop_size = args.crop_size
-    os.makedirs(os.path.join(dirname, 'train/'), exist_ok=True)
-    pm = [(0, 1, 2, 3), (2, 0, 1, 3), (1, 0, 2, 3)]
-    npm = ["YX", "ZY", "ZX"]
-    for name in image_names:
-        name0 = os.path.splitext(os.path.split(name)[-1])[0]
-        img0 = io.imread_3D(name)
-        try: 
-            img0 = transforms.convert_image(img0, channel_axis=args.channel_axis, 
-                                            z_axis=args.z_axis, do_3D=True)
-        except ValueError:
-            print('Error converting image. Did you provide the correct --channel_axis and --z_axis ?') 
-            
-        for p in range(3):
-            img = img0.transpose(pm[p]).copy()
-            print(npm[p], img[0].shape)
-            Ly, Lx = img.shape[1:3]
-            imgs = img[np.random.permutation(img.shape[0])[:args.nimg_per_tif]]
-            if args.anisotropy > 1.0 and p > 0:
-                imgs = transforms.resize_image(imgs, Ly=int(args.anisotropy * Ly), Lx=Lx)
-            for k, img in enumerate(imgs):
-                if args.tile_norm:
-                    img = transforms.normalize99_tile(img, blocksize=args.tile_norm)
-                if args.sharpen_radius:
-                    img = transforms.smooth_sharpen_img(img,
-                                                        sharpen_radius=args.sharpen_radius)
-                ly = 0 if Ly - crop_size <= 0 else np.random.randint(0, Ly - crop_size)
-                lx = 0 if Lx - crop_size <= 0 else np.random.randint(0, Lx - crop_size)
-                io.imsave(os.path.join(dirname, f'train/{name0}_{npm[p]}_{k}.tif'),
-                        img[ly:ly + args.crop_size, lx:lx + args.crop_size].squeeze())
-
-
-if __name__ == '__main__':
-    main()

models/seg_post_model/cellpose/gui/menus.py

@@ -1,145 +0,0 @@
-"""
-Copyright © 2025 Howard Hughes Medical Institute, Authored by Carsen Stringer , Michael Rariden and Marius Pachitariu.
-"""
-from qtpy.QtWidgets import QAction
-from . import io
-
-
-def mainmenu(parent):
-    main_menu = parent.menuBar()
-    file_menu = main_menu.addMenu("&File")
-    # load processed data
-    loadImg = QAction("&Load image (*.tif, *.png, *.jpg)", parent)
-    loadImg.setShortcut("Ctrl+L")
-    loadImg.triggered.connect(lambda: io._load_image(parent))
-    file_menu.addAction(loadImg)
-
-    parent.autoloadMasks = QAction("Autoload masks from _masks.tif file", parent,
-                                   checkable=True)
-    parent.autoloadMasks.setChecked(False)
-    file_menu.addAction(parent.autoloadMasks)
-
-    parent.disableAutosave = QAction("Disable autosave _seg.npy file", parent,
-                                     checkable=True)
-    parent.disableAutosave.setChecked(False)
-    file_menu.addAction(parent.disableAutosave)
-
-    parent.loadMasks = QAction("Load &masks (*.tif, *.png, *.jpg)", parent)
-    parent.loadMasks.setShortcut("Ctrl+M")
-    parent.loadMasks.triggered.connect(lambda: io._load_masks(parent))
-    file_menu.addAction(parent.loadMasks)
-    parent.loadMasks.setEnabled(False)
-
-    loadManual = QAction("Load &processed/labelled image (*_seg.npy)", parent)
-    loadManual.setShortcut("Ctrl+P")
-    loadManual.triggered.connect(lambda: io._load_seg(parent))
-    file_menu.addAction(loadManual)
-
-    parent.saveSet = QAction("&Save masks and image (as *_seg.npy)", parent)
-    parent.saveSet.setShortcut("Ctrl+S")
-    parent.saveSet.triggered.connect(lambda: io._save_sets(parent))
-    file_menu.addAction(parent.saveSet)
-    parent.saveSet.setEnabled(False)
-
-    parent.savePNG = QAction("Save masks as P&NG/tif", parent)
-    parent.savePNG.setShortcut("Ctrl+N")
-    parent.savePNG.triggered.connect(lambda: io._save_png(parent))
-    file_menu.addAction(parent.savePNG)
-    parent.savePNG.setEnabled(False)
-
-    parent.saveOutlines = QAction("Save &Outlines as text for imageJ", parent)
-    parent.saveOutlines.setShortcut("Ctrl+O")
-    parent.saveOutlines.triggered.connect(lambda: io._save_outlines(parent))
-    file_menu.addAction(parent.saveOutlines)
-    parent.saveOutlines.setEnabled(False)
-
-    parent.saveROIs = QAction("Save outlines as .zip archive of &ROI files for ImageJ",
-                              parent)
-    parent.saveROIs.setShortcut("Ctrl+R")
-    parent.saveROIs.triggered.connect(lambda: io._save_rois(parent))
-    file_menu.addAction(parent.saveROIs)
-    parent.saveROIs.setEnabled(False)
-
-    parent.saveFlows = QAction("Save &Flows and cellprob as tif", parent)
-    parent.saveFlows.setShortcut("Ctrl+F")
-    parent.saveFlows.triggered.connect(lambda: io._save_flows(parent))
-    file_menu.addAction(parent.saveFlows)
-    parent.saveFlows.setEnabled(False)
-
-
-def editmenu(parent):
-    main_menu = parent.menuBar()
-    edit_menu = main_menu.addMenu("&Edit")
-    parent.undo = QAction("Undo previous mask/trace", parent)
-    parent.undo.setShortcut("Ctrl+Z")
-    parent.undo.triggered.connect(parent.undo_action)
-    parent.undo.setEnabled(False)
-    edit_menu.addAction(parent.undo)
-
-    parent.redo = QAction("Undo remove mask", parent)
-    parent.redo.setShortcut("Ctrl+Y")
-    parent.redo.triggered.connect(parent.undo_remove_action)
-    parent.redo.setEnabled(False)
-    edit_menu.addAction(parent.redo)
-
-    parent.ClearButton = QAction("Clear all masks", parent)
-    parent.ClearButton.setShortcut("Ctrl+0")
-    parent.ClearButton.triggered.connect(parent.clear_all)
-    parent.ClearButton.setEnabled(False)
-    edit_menu.addAction(parent.ClearButton)
-
-    parent.remcell = QAction("Remove selected cell (Ctrl+CLICK)", parent)
-    parent.remcell.setShortcut("Ctrl+Click")
-    parent.remcell.triggered.connect(parent.remove_action)
-    parent.remcell.setEnabled(False)
-    edit_menu.addAction(parent.remcell)
-
-    parent.mergecell = QAction("FYI: Merge cells by Alt+Click", parent)
-    parent.mergecell.setEnabled(False)
-    edit_menu.addAction(parent.mergecell)
-
-
-def modelmenu(parent):
-    main_menu = parent.menuBar()
-    io._init_model_list(parent)
-    model_menu = main_menu.addMenu("&Models")
-    parent.addmodel = QAction("Add custom torch model to GUI", parent)
-    #parent.addmodel.setShortcut("Ctrl+A")
-    parent.addmodel.triggered.connect(parent.add_model)
-    parent.addmodel.setEnabled(True)
-    model_menu.addAction(parent.addmodel)
-
-    parent.removemodel = QAction("Remove selected custom model from GUI", parent)
-    #parent.removemodel.setShortcut("Ctrl+R")
-    parent.removemodel.triggered.connect(parent.remove_model)
-    parent.removemodel.setEnabled(True)
-    model_menu.addAction(parent.removemodel)
-
-    parent.newmodel = QAction("&Train new model with image+masks in folder", parent)
-    parent.newmodel.setShortcut("Ctrl+T")
-    parent.newmodel.triggered.connect(parent.new_model)
-    parent.newmodel.setEnabled(False)
-    model_menu.addAction(parent.newmodel)
-
-    openTrainHelp = QAction("Training instructions", parent)
-    openTrainHelp.triggered.connect(parent.train_help_window)
-    model_menu.addAction(openTrainHelp)
-
-
-def helpmenu(parent):
-    main_menu = parent.menuBar()
-    help_menu = main_menu.addMenu("&Help")
-
-    openHelp = QAction("&Help with GUI", parent)
-    openHelp.setShortcut("Ctrl+H")
-    openHelp.triggered.connect(parent.help_window)
-    help_menu.addAction(openHelp)
-
-    openGUI = QAction("&GUI layout", parent)
-    openGUI.setShortcut("Ctrl+G")
-    openGUI.triggered.connect(parent.gui_window)
-    help_menu.addAction(openGUI)
-
-    openTrainHelp = QAction("Training instructions", parent)
-    openTrainHelp.triggered.connect(parent.train_help_window)
-    help_menu.addAction(openTrainHelp)

models/seg_post_model/cellpose/vit_sam_new.py

@@ -1,197 +0,0 @@
-"""
-Copyright © 2025 Howard Hughes Medical Institute, Authored by Carsen Stringer and Marius Pachitariu.
-"""
-
-import torch
-from segment_anything import sam_model_registry
-torch.backends.cuda.matmul.allow_tf32 = True
-from torch import nn 
-import torch.nn.functional as F
-
-class Transformer(nn.Module):
-    def __init__(self, backbone="vit_l", ps=16, nout=3, bsize=256, rdrop=0.4,
-                  checkpoint=None, dtype=torch.float32):
-        super(Transformer, self).__init__()
-        """
-        print(self.encoder.patch_embed)
-            PatchEmbed(
-            (proj): Conv2d(3, 1024, kernel_size=(16, 16), stride=(16, 16))
-            )
-        print(self.encoder.neck)
-            Sequential(
-            (0): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
-            (1): LayerNorm2d()
-            (2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
-            (3): LayerNorm2d()
-            )
-        """
-        # instantiate the vit model, default to not loading SAM
-        # checkpoint = sam_vit_l_0b3195.pth is standard pretrained SAM
-        if checkpoint is None:
-            checkpoint = "sam_vit_l_0b3195.pth"
-        self.encoder = sam_model_registry[backbone](checkpoint).image_encoder
-        w = self.encoder.patch_embed.proj.weight.detach()
-        nchan = w.shape[0]
-        
-        # change token size to ps x ps
-        self.ps = ps
-        # self.encoder.patch_embed.proj = nn.Conv2d(3, nchan, stride=ps, kernel_size=ps)
-        # self.encoder.patch_embed.proj.weight.data = w[:,:,::16//ps,::16//ps]
-        
-        # adjust position embeddings for new bsize and new token size
-        ds = (1024 // 16) // (bsize // ps)
-        self.encoder.pos_embed = nn.Parameter(self.encoder.pos_embed[:,::ds,::ds], requires_grad=True)
-
-        # readout weights for nout output channels
-        # if nout is changed, weights will not load correctly from pretrained Cellpose-SAM
-        self.nout = nout
-        self.out = nn.Conv2d(256, self.nout * ps**2, kernel_size=1)
-
-        # W2 reshapes token space to pixel space, not trainable
-        self.W2 = nn.Parameter(torch.eye(self.nout * ps**2).reshape(self.nout*ps**2, self.nout, ps, ps), 
-                               requires_grad=False)
-        
-        # fraction of layers to drop at random during training
-        self.rdrop = rdrop
-
-        # average diameter of ROIs from training images from fine-tuning 
-        self.diam_labels = nn.Parameter(torch.tensor([30.]), requires_grad=False)
-        # average diameter of ROIs during main training
-        self.diam_mean = nn.Parameter(torch.tensor([30.]), requires_grad=False)
-        
-        # set attention to global in every layer
-        for blk in self.encoder.blocks:
-            blk.window_size = 0
-
-        self.dtype = dtype
-
-    def forward(self, x, feat=None):      
-        # same progression as SAM until readout
-        x = self.encoder.patch_embed(x)
-        if feat is not None:
-            feat = self.encoder.patch_embed(feat)
-            x = x + x * feat * 0.5
-        
-        if self.encoder.pos_embed is not None:
-            x = x + self.encoder.pos_embed
-        
-        if self.training and self.rdrop > 0:
-            nlay = len(self.encoder.blocks)
-            rdrop = (torch.rand((len(x), nlay), device=x.device) < 
-                     torch.linspace(0, self.rdrop, nlay, device=x.device)).to(x.dtype)
-            for i, blk in enumerate(self.encoder.blocks):            
-                mask = rdrop[:,i].unsqueeze(-1).unsqueeze(-1).unsqueeze(-1)
-                x = x * mask + blk(x) * (1-mask)
-        else:
-            for blk in self.encoder.blocks:
-                x = blk(x)
-
-        x = self.encoder.neck(x.permute(0, 3, 1, 2))
-
-        # readout is changed here
-        x1 = self.out(x)
-        x1 = F.conv_transpose2d(x1, self.W2, stride = self.ps, padding = 0)
-        
-        # maintain the second output of feature size 256 for backwards compatibility
-           
-        return x1, torch.randn((x.shape[0], 256), device=x.device)
-    
-    def load_model(self, PATH, device, strict = False):        
-        state_dict = torch.load(PATH, map_location = device, weights_only=True)
-        keys = [k for k in state_dict.keys()]
-        if keys[0][:7] == "module.":
-            from collections import OrderedDict
-            new_state_dict = OrderedDict()
-            for k, v in state_dict.items():
-                name = k[7:] # remove 'module.' of DataParallel/DistributedDataParallel
-                new_state_dict[name] = v
-            self.load_state_dict(new_state_dict, strict = strict)
-        else:
-            self.load_state_dict(state_dict, strict = strict)
-
-        if self.dtype != torch.float32:
-            self = self.to(self.dtype)
-
-    
-    @property
-    def device(self):
-        """
-        Get the device of the model.
-
-        Returns:
-            torch.device: The device of the model.
-        """
-        return next(self.parameters()).device
-
-    def save_model(self, filename):
-        """
-        Save the model to a file.
-
-        Args:
-            filename (str): The path to the file where the model will be saved.
-        """
-        torch.save(self.state_dict(), filename)
-
-
-
-class CPnetBioImageIO(Transformer):
-    """
-    A subclass of the CP-SAM model compatible with the BioImage.IO Spec.
-
-    This subclass addresses the limitation of CPnet's incompatibility with the BioImage.IO Spec,
-    allowing the CPnet model to use the weights uploaded to the BioImage.IO Model Zoo.
-    """
-
-    def forward(self, x):
-        """
-        Perform a forward pass of the CPnet model and return unpacked tensors.
-
-        Args:
-            x (torch.Tensor): Input tensor.
-
-        Returns:
-            tuple: A tuple containing the output tensor, style tensor, and downsampled tensors.
-        """
-        output_tensor, style_tensor, downsampled_tensors = super().forward(x)
-        return output_tensor, style_tensor, *downsampled_tensors
-    
-
-    def load_model(self, filename, device=None):
-        """
-        Load the model from a file.
-
-        Args:
-            filename (str): The path to the file where the model is saved.
-            device (torch.device, optional): The device to load the model on. Defaults to None.
-        """
-        if (device is not None) and (device.type != "cpu"):
-            state_dict = torch.load(filename, map_location=device, weights_only=True)
-        else:
-            self.__init__(self.nout)
-            state_dict = torch.load(filename, map_location=torch.device("cpu"), 
-                                    weights_only=True)
-
-        self.load_state_dict(state_dict)
-
-    def load_state_dict(self, state_dict):
-        """
-        Load the state dictionary into the model.
-
-        This method overrides the default `load_state_dict` to handle Cellpose's custom
-        loading mechanism and ensures compatibility with BioImage.IO Core.
-
-        Args:
-            state_dict (Mapping[str, Any]): A state dictionary to load into the model
-        """
-        if state_dict["output.2.weight"].shape[0] != self.nout:
-            for name in self.state_dict():
-                if "output" not in name:
-                    self.state_dict()[name].copy_(state_dict[name])
-        else:
-            super().load_state_dict(
-                {name: param for name, param in state_dict.items()},
-                strict=False)
-
-
-    
-