deepliif 1.1.13__py3-none-any.whl → 1.1.15__py3-none-any.whl

deepliif/models/__init__.py

@@ -25,6 +25,8 @@ from functools import lru_cache
 from io import BytesIO
 import json
 import math
+import importlib.metadata
+import pathlib
 
 import requests
 import torch
@@ -37,7 +39,7 @@ from dask import delayed, compute
 from deepliif.util import *
 from deepliif.util.util import tensor_to_pil
 from deepliif.data import transform
-from deepliif.postprocessing import compute_final_results, compute_cell_results
+from deepliif.postprocessing import compute_final_results, compute_cell_results, to_array
 from deepliif.postprocessing import encode_cell_data_v4, decode_cell_data_v4
 from deepliif.options import Options, print_options
 
@@ -167,7 +169,7 @@ def init_nets(model_dir, eager_mode=False, opt=None, phase='test'):
         opt = get_opt(model_dir, mode=phase)
     opt.use_dp = False
     
-    if opt.model == 'DeepLIIF':
+    if opt.model in ['DeepLIIF','DeepLIIFKD']:
         net_groups = [
             ('G1', 'G52'),
             ('G2', 'G53'),
@@ -217,13 +219,15 @@ def compute_overlap(img_size, tile_size):
     return tile_size // 4
 
 
-def run_torchserve(img, model_path=None, eager_mode=False, opt=None, seg_only=False):
+def run_torchserve(img, model_path=None, nets=None, eager_mode=False, opt=None, seg_only=False, seg_weights=None, use_dask=True, output_tensor=False):
     """
     eager_mode: not used in this function; put in place to be consistent with run_dask
            so that run_wrapper() could call either this function or run_dask with
            same syntax
     opt: same as eager_mode
     seg_only: same as eager_mode
+    seg_weights: same as eager_mode
+    nets: same as eager_mode
     """
     buffer = BytesIO()
     torch.save(transform(img.resize((opt.scale_size, opt.scale_size))), buffer)
@@ -242,16 +246,28 @@ def run_torchserve(img, model_path=None, eager_mode=False, opt=None, seg_only=Fa
     return {k: tensor_to_pil(deserialize_tensor(v)) for k, v in res.json().items()}
 
 
-def run_dask(img, model_path, eager_mode=False, opt=None, seg_only=False):
-    model_dir = os.getenv('DEEPLIIF_MODEL_DIR', model_path)
-    nets = init_nets(model_dir, eager_mode, opt)
-    use_dask = True if opt.norm != 'spectral' else False
+def run_dask(img, model_path=None, nets=None, eager_mode=False, opt=None, seg_only=False, seg_weights=None, use_dask=True, output_tensor=False):
+    """
+    Provide either the model path or the networks object.
+    
+    `eager_mode` is only applicable if model_path is provided.
+    """
+    assert model_path is not None or nets is not None, 'Provide either the model path or the networks object.'
+    if nets is None:
+        model_dir = os.getenv('DEEPLIIF_MODEL_DIR', model_path)
+        nets = init_nets(model_dir, eager_mode, opt)
     
-    if opt.input_no > 1 or opt.model == 'SDG':
-        l_ts = [transform(img_i.resize((opt.scale_size,opt.scale_size))) for img_i in img]
-        ts = torch.cat(l_ts, dim=1)
+    if use_dask: # check if use_dask should be overwritten
+        use_dask = True if opt.norm != 'spectral' else False
+    
+    if isinstance(img,torch.Tensor): # if img input is already a tensor, pass
+        ts = img
     else:
-        ts = transform(img.resize((opt.scale_size, opt.scale_size)))
+        if opt.input_no > 1 or opt.model == 'SDG':
+            l_ts = [transform(img_i.resize((opt.scale_size,opt.scale_size))) for img_i in img]
+            ts = torch.cat(l_ts, dim=1)
+        else:
+            ts = transform(img.resize((opt.scale_size, opt.scale_size)))
     
 
     if use_dask:
@@ -264,14 +280,23 @@ def run_dask(img, model_path, eager_mode=False, opt=None, seg_only=False):
             with torch.no_grad():
                 return model(input.to(next(model.parameters()).device))
     
-    if opt.model == 'DeepLIIF':
-        weights = {
-            'G51': 0.25, # IHC
-            'G52': 0.25, # Hema
-            'G53': 0.25, # DAPI
-            'G54': 0.00, # Lap2
-            'G55': 0.25, # Marker
-        }
+    if opt.model in ['DeepLIIF','DeepLIIFKD']:
+        if seg_weights is None:
+            weights = {
+                'G51': 0.25, # IHC
+                'G52': 0.25, # Hema
+                'G53': 0.25, # DAPI
+                'G54': 0.00, # Lap2
+                'G55': 0.25, # Marker
+            }
+        else:
+            weights = {
+                'G51': seg_weights[0], # IHC
+                'G52': seg_weights[1], # Hema
+                'G53': seg_weights[2], # DAPI
+                'G54': seg_weights[3], # Lap2
+                'G55': seg_weights[4], # Marker
+            }
 
         seg_map = {'G1': 'G52', 'G2': 'G53', 'G3': 'G54', 'G4': 'G55'}
         if seg_only:
@@ -282,19 +307,27 @@ def run_dask(img, model_path, eager_mode=False, opt=None, seg_only=False):
             lazy_gens['G4'] = forward(ts, nets['G4'])
         gens = compute(lazy_gens)[0]
         
-        lazy_segs = {v: forward(gens[k], nets[v]).to(torch.device('cpu')) for k, v in seg_map.items()}
+        lazy_segs = {v: forward(gens[k], nets[v]) for k, v in seg_map.items()}
         if not seg_only or weights['G51'] != 0:
-            lazy_segs['G51'] = forward(ts, nets['G51']).to(torch.device('cpu'))
+            lazy_segs['G51'] = forward(ts, nets['G51'])
         segs = compute(lazy_segs)[0]
-    
-        seg = torch.stack([torch.mul(segs[k], weights[k]) for k in segs.keys()]).sum(dim=0)
-    
-        if seg_only:
-            res = {'G4': tensor_to_pil(gens['G4'])} if 'G4' in gens else {}
+        
+        device = next(nets['G1'].parameters()).device # take the device of the first net and move all outputs there for seg aggregation
+        seg = torch.stack([torch.mul(segs[k].to(device), weights[k]) for k in segs.keys()]).sum(dim=0)
+        
+        if output_tensor:
+            if seg_only:
+                res = {'G4': gens['G4']} if 'G4' in gens else {}
+            else:
+                res = {**gens, **segs}
+            res['G5'] = seg
         else:
-            res = {k: tensor_to_pil(v) for k, v in gens.items()}
-            res.update({k: tensor_to_pil(v) for k, v in segs.items()})
-        res['G5'] = tensor_to_pil(seg)
+            if seg_only:
+                res = {'G4': tensor_to_pil(gens['G4'].to(torch.device('cpu')))} if 'G4' in gens else {}
+            else:
+                res = {k: tensor_to_pil(v.to(torch.device('cpu'))) for k, v in gens.items()}
+                res.update({k: tensor_to_pil(v.to(torch.device('cpu'))) for k, v in segs.items()})
+            res['G5'] = tensor_to_pil(seg.to(torch.device('cpu')))
     
         return res
     elif opt.model in ['DeepLIIFExt','SDG','CycleGAN']:
@@ -327,13 +360,13 @@ def run_dask(img, model_path, eager_mode=False, opt=None, seg_only=False):
 def is_empty(tile):
     thresh = 15
     if isinstance(tile, list): # for pair of tiles, only mark it as empty / no need for prediction if ALL tiles are empty
-        return all([True if np.max(image_variance_rgb(t)) < thresh else False for t in tile])
+        return all([True if image_variance_gray(t) < thresh else False for t in tile])
     else:
-        return True if np.max(image_variance_rgb(tile)) < thresh else False
+        return True if image_variance_gray(tile) < thresh else False
 
 
-def run_wrapper(tile, run_fn, model_path, eager_mode=False, opt=None, seg_only=False):
-    if opt.model == 'DeepLIIF':
+def run_wrapper(tile, run_fn, model_path=None, nets=None, eager_mode=False, opt=None, seg_only=False, seg_weights=None, use_dask=True, output_tensor=False):
+    if opt.model in ['DeepLIIF','DeepLIIFKD']:
         if is_empty(tile):
             if seg_only:
                 return {
@@ -354,31 +387,38 @@ def run_wrapper(tile, run_fn, model_path, eager_mode=False, opt=None, seg_only=F
                     'G55': Image.new(mode='RGB', size=(512, 512), color=(0, 0, 0)),
                 }
         else:
-            return run_fn(tile, model_path, eager_mode, opt, seg_only)
+            return run_fn(tile, model_path, None, eager_mode, opt, seg_only, seg_weights)
     elif opt.model in ['DeepLIIFExt', 'SDG']:
         if is_empty(tile):
             res = {'G_' + str(i): Image.new(mode='RGB', size=(512, 512)) for i in range(1, opt.modalities_no + 1)}
             res.update({'GS_' + str(i): Image.new(mode='RGB', size=(512, 512)) for i in range(1, opt.modalities_no + 1)})
             return res
         else:
-            return run_fn(tile, model_path, eager_mode, opt)
+            return run_fn(tile, model_path, None, eager_mode, opt)
     elif opt.model in ['CycleGAN']:
         if is_empty(tile):
             net_names = ['GB_{i+1}' for i in range(opt.modalities_no)] if opt.BtoA else [f'GA_{i+1}' for i in range(opt.modalities_no)]
             res = {net_name: Image.new(mode='RGB', size=(512, 512)) for net_name in net_names}
             return res
         else:
-            return run_fn(tile, model_path, eager_mode, opt)
+            return run_fn(tile, model_path, None, eager_mode, opt)
     else:
         raise Exception(f'run_wrapper() not implemented for model {opt.model}')
 
 
 def inference(img, tile_size, overlap_size, model_path, use_torchserve=False,
               eager_mode=False, color_dapi=False, color_marker=False, opt=None,
-              return_seg_intermediate=False, seg_only=False):
+              return_seg_intermediate=False, seg_only=False, seg_weights=None, opt_args={}):
+    """
+    opt_args: a dictionary of key and values to add/overwrite to opt
+    """
     if not opt:
         opt = get_opt(model_path)
         #print_options(opt)
+    
+    for k,v in opt_args.items():
+        setattr(opt,k,v)
+    #print_options(opt)
 
     run_fn = run_torchserve if use_torchserve else run_dask
 
@@ -393,10 +433,11 @@ def inference(img, tile_size, overlap_size, model_path, use_torchserve=False,
 
     tiler = InferenceTiler(orig, tile_size, overlap_size)
     for tile in tiler:
-        tiler.stitch(run_wrapper(tile, run_fn, model_path, eager_mode, opt, seg_only))
+        tiler.stitch(run_wrapper(tile, run_fn, model_path, None, eager_mode, opt, seg_only, seg_weights))
+        
     results = tiler.results()
 
-    if opt.model == 'DeepLIIF':
+    if opt.model in ['DeepLIIF','DeepLIIFKD']:
         if seg_only:
             images = {'Seg': results['G5']}
             if 'G4' in results:
@@ -445,7 +486,7 @@ def inference(img, tile_size, overlap_size, model_path, use_torchserve=False,
 
 
 def postprocess(orig, images, tile_size, model, seg_thresh=150, size_thresh='default', marker_thresh=None, size_thresh_upper=None):
-    if model == 'DeepLIIF':
+    if model in ['DeepLIIF','DeepLIIFKD']:
         resolution = '40x' if tile_size > 384 else ('20x' if tile_size > 192 else '10x')
         overlay, refined, scoring = compute_final_results(
             orig, images['Seg'], images.get('Marker'), resolution,
@@ -477,7 +518,7 @@ def postprocess(orig, images, tile_size, model, seg_thresh=150, size_thresh='def
 
 def infer_modalities(img, tile_size, model_dir, eager_mode=False,
                      color_dapi=False, color_marker=False, opt=None,
-                     return_seg_intermediate=False, seg_only=False):
+                     return_seg_intermediate=False, seg_only=False, seg_weights=None):
     """
     This function is used to infer modalities for the given image using a trained model.
     :param img: The input image.
@@ -505,7 +546,8 @@ def infer_modalities(img, tile_size, model_dir, eager_mode=False,
         color_marker=color_marker,
         opt=opt,
         return_seg_intermediate=return_seg_intermediate,
-        seg_only=seg_only
+        seg_only=seg_only,
+        seg_weights=seg_weights,
     )
 
     if not hasattr(opt,'seg_gen') or (hasattr(opt,'seg_gen') and opt.seg_gen): # the first condition accounts for old settings of deepliif; the second refers to deepliifext models
@@ -520,7 +562,7 @@ def infer_modalities(img, tile_size, model_dir, eager_mode=False,
         return images, None
 
 
-def infer_results_for_wsi(input_dir, filename, output_dir, model_dir, tile_size, region_size=20000, color_dapi=False, color_marker=False, seg_intermediate=False, seg_only=False):
+def infer_results_for_wsi(input_dir, filename, output_dir, model_dir, tile_size, region_size=20000, color_dapi=False, color_marker=False, seg_intermediate=False, seg_only=False, seg_weights=None):
     """
     This function infers modalities and segmentation mask for the given WSI image. It
 
@@ -554,7 +596,7 @@ def infer_results_for_wsi(input_dir, filename, output_dir, model_dir, tile_size,
                 region = reader.read(XYWH=region_XYWH, rescale=rescale)
                 img = Image.fromarray((region * 255).astype(np.uint8)) if rescale else Image.fromarray(region)
 
-                region_modalities, region_scoring = infer_modalities(img, tile_size, model_dir, color_dapi=color_dapi, color_marker=color_marker, return_seg_intermediate=seg_intermediate, seg_only=seg_only)
+                region_modalities, region_scoring = infer_modalities(img, tile_size, model_dir, color_dapi=color_dapi, color_marker=color_marker, return_seg_intermediate=seg_intermediate, seg_only=seg_only, seg_weights=seg_weights)
                 if region_scoring is not None:
                     if scoring is None:
                         scoring = {
@@ -586,8 +628,6 @@ def infer_results_for_wsi(input_dir, filename, output_dir, model_dir, tile_size,
         with open(os.path.join(results_dir, f'{basename}.json'), 'w') as f:
             json.dump(scoring, f, indent=2)
 
-    javabridge.kill_vm()
-
 
 def get_wsi_resolution(filename):
     """
@@ -595,9 +635,6 @@ def get_wsi_resolution(filename):
     the corresponding tile size to use by default for DeepLIIF.
     If it cannot be found, return (None, None) instead.
 
-    Note: This will start the javabridge VM, but not kill it.
-          It must be killed elsewhere.
-
     Parameters
     ----------
     filename : str
@@ -611,11 +648,10 @@ def get_wsi_resolution(filename):
         Corresponding tile size for DeepLIIF.
     """
 
-    # make sure javabridge is already set up from with call to get_information()
-    size_x, size_y, size_z, size_c, size_t, pixel_type = get_information(filename)
+    init_javabridge_bioformats()
+    metadata = bioformats.get_omexml_metadata(filename)
 
     mag = None
-    metadata = bioformats.get_omexml_metadata(filename)
     try:
         omexml = bioformats.OMEXML(metadata)
         mag = omexml.instrument().Objective.NominalMagnification
@@ -648,7 +684,7 @@ def get_wsi_resolution(filename):
         return None, None
 
 
-def infer_cells_for_wsi(filename, model_dir, tile_size, region_size=20000, version=3, print_log=False):
+def infer_cells_for_wsi(filename, model_dir, tile_size, region_size=20000, version=3, print_log=False, seg_weights=None):
     """
     Perform inference on a slide and get the results individual cell data.
 
@@ -666,6 +702,9 @@ def infer_cells_for_wsi(filename, model_dir, tile_size, region_size=20000, versi
         Version of cell data to return (3 or 4).
     print_log : bool
         Whether or not to print updates while processing.
+    seg_weights : list | tuple
+        Optional five weights to use for creating the combined Seg image.
+        If None, then the default weights are used.
 
     Returns
     -------
@@ -679,22 +718,21 @@ def infer_cells_for_wsi(filename, model_dir, tile_size, region_size=20000, versi
 
     resolution = '40x' if tile_size > 384 else ('20x' if tile_size > 192 else '10x')
 
-    size_x, size_y, size_z, size_c, size_t, pixel_type = get_information(filename)
-    rescale = (pixel_type != 'uint8')
-    print_info('Info:', size_x, size_y, size_z, size_c, size_t, pixel_type)
-
-    num_regions_x = math.ceil(size_x / region_size)
-    num_regions_y = math.ceil(size_y / region_size)
-    stride_x = math.ceil(size_x / num_regions_x)
-    stride_y = math.ceil(size_y / num_regions_y)
-    print_info('Strides:', stride_x, stride_y)
-
     data = None
     default_marker_thresh, count_marker_thresh = 0, 0
     default_size_thresh, count_size_thresh = 0, 0
 
-    # javabridge already set up from previous call to get_information()
-    with bioformats.ImageReader(filename) as reader:
+    with WSIReader(filename) as reader:
+        size_x = reader.width
+        size_y = reader.height
+        print_info('Info:', size_x, size_y)
+
+        num_regions_x = math.ceil(size_x / region_size)
+        num_regions_y = math.ceil(size_y / region_size)
+        stride_x = math.ceil(size_x / num_regions_x)
+        stride_y = math.ceil(size_y / num_regions_y)
+        print_info('Strides:', stride_x, stride_y)
+
         start_x, start_y = 0, 0
 
         while start_y < size_y:
@@ -702,10 +740,11 @@ def infer_cells_for_wsi(filename, model_dir, tile_size, region_size=20000, versi
                 region_XYWH = (start_x, start_y, min(stride_x, size_x-start_x), min(stride_y, size_y-start_y))
                 print_info('Region:', region_XYWH)
 
-                region = reader.read(XYWH=region_XYWH, rescale=rescale)
+                region = reader.read(region_XYWH)
                 print_info(region.shape, region.dtype)
-                img = Image.fromarray((region * 255).astype(np.uint8)) if rescale else Image.fromarray(region)
+                img = Image.fromarray(region)
                 print_info(img.size, img.mode)
+                del region
 
                 images = inference(
                     img,
@@ -718,8 +757,17 @@ def infer_cells_for_wsi(filename, model_dir, tile_size, region_size=20000, versi
                     opt=None,
                     return_seg_intermediate=False,
                     seg_only=True,
+                    seg_weights=seg_weights,
                 )
-                region_data = compute_cell_results(images['Seg'], images.get('Marker'), resolution, version=version)
+                del img
+
+                seg = to_array(images['Seg'])
+                del images['Seg']
+                marker = to_array(images['Marker'], True) if 'Marker' in images else None
+                del images
+                region_data = compute_cell_results(seg, marker, resolution, version=version)
+                del seg
+                del marker
 
                 if start_x != 0 or start_y != 0:
                     for i in range(len(region_data['cells'])):
@@ -748,8 +796,6 @@ def infer_cells_for_wsi(filename, model_dir, tile_size, region_size=20000, versi
             start_x = 0
             start_y += stride_y
 
-    javabridge.kill_vm()
-
     if count_marker_thresh == 0:
         count_marker_thresh = 1
     if count_size_thresh == 0:
@@ -757,4 +803,18 @@ def infer_cells_for_wsi(filename, model_dir, tile_size, region_size=20000, versi
     data['settings']['default_marker_thresh'] = round(default_marker_thresh / count_marker_thresh)
     data['settings']['default_size_thresh'] = round(default_size_thresh / count_size_thresh)
 
+    data['settings']['tile_size'] = tile_size
+    data['settings']['region_size'] = region_size
+    data['settings']['seg_weights'] = seg_weights
+
+    try:
+        data['deepliifVersion'] = importlib.metadata.version('deepliif')
+    except Exception as e:
+        data['deepliifVersion'] = 'unknown'
+
+    try:
+        data['modelVersion'] = pathlib.PurePath(model_dir).name
+    except Exception as e:
+        data['modelVersion'] = 'unknown'
+
     return data

deepliif/models/base_model.py

@@ -147,7 +147,7 @@ class BaseModel(ABC):
             if isinstance(name, str):
                 if not hasattr(self, name):
                     if len(name.split('_')) != 2:
-                        if self.opt.model == 'DeepLIIF':
+                        if self.opt.model in ['DeepLIIF','DeepLIIFKD']:
                             img_name = name[:-1] + '_' + name[-1]
                             visual_ret[name] = getattr(self, img_name)
                         else:

deepliif/models/networks.py

@@ -172,12 +172,14 @@ def define_G(
     norm_layer = get_norm_layer(norm_type=norm)
     use_spectral_norm = norm == 'spectral'
 
-    if netG == 'resnet_9blocks':
-        net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, n_blocks=9, 
-                              padding_type=padding_type, upsample=upsample, use_spectral_norm=use_spectral_norm)
-    elif netG == 'resnet_6blocks':
-        net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, n_blocks=6, 
+    if netG.startswith('resnet_'):
+        n_blocks = int(netG.split('_')[1].replace('blocks',''))
+        net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, n_blocks=n_blocks, 
                               padding_type=padding_type, upsample=upsample, use_spectral_norm=use_spectral_norm)
+    elif netG == 'unet_32':
+        net = UnetGenerator(input_nc, output_nc, 5, ngf, norm_layer=norm_layer, use_dropout=use_dropout)
+    elif netG == 'unet_64':
+        net = UnetGenerator(input_nc, output_nc, 6, ngf, norm_layer=norm_layer, use_dropout=use_dropout)
     elif netG == 'unet_128':
         net = UnetGenerator(input_nc, output_nc, 7, ngf, norm_layer=norm_layer, use_dropout=use_dropout)
     elif netG == 'unet_256':

deepliif/postprocessing.py

@@ -184,32 +184,38 @@ def mark_background(mask):
         After the function executes, the pixels will be labeled as background, positive, negative, or unknown.
     """
 
-    seeds = []
     for i in range(mask.shape[0]):
         if mask[i, 0] == LABEL_UNKNOWN:
-            seeds.append((i, 0))
+            mask[i, 0] = LABEL_BACKGROUND
         if mask[i, mask.shape[1]-1] == LABEL_UNKNOWN:
-            seeds.append((i, mask.shape[1]-1))
+            mask[i, mask.shape[1]-1] = LABEL_BACKGROUND
     for j in range(mask.shape[1]):
         if mask[0, j] == LABEL_UNKNOWN:
-            seeds.append((0, j))
+            mask[0, j] = LABEL_BACKGROUND
         if mask[mask.shape[0]-1, j] == LABEL_UNKNOWN:
-            seeds.append((mask.shape[0]-1, j))
-
-    neighbors = [(-1, 0), (1, 0), (0, -1), (0, 1)]
-
-    while len(seeds) > 0:
-        seed = seeds.pop()
-        if mask[seed] == LABEL_UNKNOWN:
-            mask[seed] = LABEL_BACKGROUND
-            for n in neighbors:
-                idx = (seed[0] + n[0], seed[1] + n[1])
-                if in_bounds(mask, idx) and mask[idx] == LABEL_UNKNOWN:
-                    seeds.append(idx)
+            mask[mask.shape[0]-1, j] = LABEL_BACKGROUND
+
+    count = 1
+    while count > 0:
+        count = 0
+        for i in range(mask.shape[0]):
+            for j in range(mask.shape[1]):
+                if mask[i, j] == LABEL_UNKNOWN:
+                    if (mask[i-1, j] == LABEL_BACKGROUND or mask[i+1, j] == LABEL_BACKGROUND or
+                            mask[i, j-1] == LABEL_BACKGROUND or mask[i, j+1] == LABEL_BACKGROUND):
+                        mask[i, j] = LABEL_BACKGROUND
+                        count += 1
+        if count > 0:
+            for i in range(mask.shape[0]-1, -1, -1):
+                for j in range(mask.shape[1]-1, -1, -1):
+                    if mask[i, j] == LABEL_UNKNOWN:
+                        if (mask[i-1, j] == LABEL_BACKGROUND or mask[i+1, j] == LABEL_BACKGROUND or
+                                mask[i, j-1] == LABEL_BACKGROUND or mask[i, j+1] == LABEL_BACKGROUND):
+                            mask[i, j] = LABEL_BACKGROUND
 
 
 @jit(nopython=True)
-def compute_cell_mapping(mask, marker, noise_thresh):
+def compute_cell_mapping(mask, marker, noise_thresh, large_noise_thresh):
     """
     Compute the mapping from mask to positive and negative cells.
 
@@ -264,7 +270,7 @@ def compute_cell_mapping(mask, marker, noise_thresh):
                             center_x += idx[1]
                             count += 1
 
-                if count > noise_thresh:
+                if count > noise_thresh and (large_noise_thresh is None or count < large_noise_thresh):
                     center_y = int(round(center_y / count))
                     center_x = int(round(center_x / count))
                     positive = True if count_positive >= count_negative else False
@@ -273,7 +279,7 @@ def compute_cell_mapping(mask, marker, noise_thresh):
     return cells
 
 
-def get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh):
+def get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh, large_noise_thresh):
     """
     Find all cells in the segmentation image that are larger than the noise threshold.
 
@@ -289,6 +295,8 @@ def get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh):
         Threshold for tiny noise to ignore (include only cells larger than this value).
     seg_thresh : int
         Threshold to use in determining if a pixel should be labeled as positive/negative.
+    large_noise_thresh : int | None
+        Threshold for large noise to ignore (include only cells smaller than this value).
 
     Returns
     -------
@@ -303,9 +311,10 @@ def get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh):
     seg = to_array(seg)
     if marker is not None:
         marker = to_array(marker, True)
+
     mask = create_posneg_mask(seg, seg_thresh)
     mark_background(mask)
-    cellsinfo = compute_cell_mapping(mask, marker, noise_thresh)
+    cellsinfo = compute_cell_mapping(mask, marker, noise_thresh, large_noise_thresh)
 
     defaults = {}
     sizes = np.zeros(len(cellsinfo), dtype=np.int64)
@@ -1040,9 +1049,21 @@ def fill_cells(mask):
                     mask[y, x] = LABEL_NEGATIVE
 
 
+def calculate_large_noise_thresh(large_noise_thresh, resolution):
+    if large_noise_thresh != 'default':
+        return large_noise_thresh
+    if resolution == '10x':
+        return 250
+    elif resolution == '20x':
+        return 1000
+    else: # 40x
+        return 4000
+
+
 def compute_cell_results(seg, marker, resolution, version=3,
                          seg_thresh=DEFAULT_SEG_THRESH,
-                         noise_thresh=DEFAULT_NOISE_THRESH):
+                         noise_thresh=DEFAULT_NOISE_THRESH,
+                         large_noise_thresh='default'):
     """
     Perform postprocessing to compute individual cell results.
 
@@ -1060,6 +1081,9 @@ def compute_cell_results(seg, marker, resolution, version=3,
         Threshold to use in determining if a pixel should be labeled as positive/negative.
     noise_thresh : int
         Threshold for tiny noise to ignore (include only cells larger than this value).
+    large_noise_thresh : int | string | None
+        Threshold for large noise to ignore (include only cells smaller than this value).
+        Valid arguments can be an integer value, the string value 'default', or None.
 
     Returns
     -------
@@ -1071,7 +1095,8 @@ def compute_cell_results(seg, marker, resolution, version=3,
         warnings.warn('Invalid cell data version provided, defaulting to version 3.')
         version = 3
 
-    mask, cellsinfo, defaults = get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh)
+    large_noise_thresh = calculate_large_noise_thresh(large_noise_thresh, resolution)
+    mask, cellsinfo, defaults = get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh, large_noise_thresh)
 
     cells = []
     for cell in cellsinfo:
@@ -1094,6 +1119,7 @@ def compute_cell_results(seg, marker, resolution, version=3,
             'default_marker_thresh': defaults['marker_thresh'] if 'marker_thresh' in defaults else None,
             'default_size_thresh': defaults['size_thresh'],
             'noise_thresh': noise_thresh,
+            'large_noise_thresh': large_noise_thresh,
             'seg_thresh': seg_thresh,
         },
         'dataVersion': version,
@@ -1107,7 +1133,8 @@ def compute_final_results(orig, seg, marker, resolution,
                           marker_thresh=None,
                           size_thresh_upper=None,
                           seg_thresh=DEFAULT_SEG_THRESH,
-                          noise_thresh=DEFAULT_NOISE_THRESH):
+                          noise_thresh=DEFAULT_NOISE_THRESH,
+                          large_noise_thresh='default'):
     """
     Perform postprocessing to compute final count and image results.
 
@@ -1131,6 +1158,9 @@ def compute_final_results(orig, seg, marker, resolution,
         Threshold to use in determining if a pixel should be labeled as positive/negative.
     noise_thresh : int
         Threshold for tiny noise to ignore (include only cells larger than this value).
+    large_noise_thresh : int | string | None
+        Threshold for large noise to ignore (include only cells smaller than this value).
+        Valid arguments can be an integer value, the string value 'default', or None.
 
     Returns
     -------
@@ -1142,7 +1172,8 @@ def compute_final_results(orig, seg, marker, resolution,
         Dictionary with scoring and settings information.
     """
 
-    mask, cellsinfo, defaults = get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh)
+    large_noise_thresh = calculate_large_noise_thresh(large_noise_thresh, resolution)
+    mask, cellsinfo, defaults = get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh, large_noise_thresh)
 
     if size_thresh is None:
         size_thresh = 0