ct-segmentation-toolkit 0.2.0__py3-none-any.whl

ct_seg/denoise/denoise_volume.py

@@ -0,0 +1,164 @@
+"""
+denoise_volume.py — Denoise a full CT volume (or a slice range) with 2.5D N2I.
+
+Loads the best edge-score checkpoint from training (main.py) and denoises every
+slice of the full reconstruction, writing the result as a TIFF stack into a
+`denoised_volume/` folder next to the reconstructions. A contiguous slice range
+may be given to denoise only part of the volume (useful for quick evaluation); if
+omitted, the whole volume is processed.
+
+To use the GPU efficiently the script auto-tunes the inference batch size for the
+available GPU memory, model size, and image dimensions (see
+InferenceBatchSizeOptimizer in data.py). Normalization uses the mean/std that
+training wrote back into the config file.
+
+Inputs  : a YAML config (with mean4norm/std4norm filled in by training) and an
+          optional [start_slice, end_slice] range.
+Outputs : <reconstruction_dir>/denoised_volume/<index>.tiff stack
+          (this folder is deleted and recreated on every run).
+
+Usage:
+    python denoise_volume.py -gpus=0 -config=/path/to/config.yaml -start_slice=500 -end_slice=600
+    (normally launched via denoise_volume.sh; omit the range to denoise everything)
+
+Author:  Cameron Renteria <crentb23@gmail.com>
+License: Apache-2.0 (see LICENSE)
+"""
+
+import argparse
+import logging
+import os
+import shutil
+import sys
+import time
+import warnings
+
+import numpy as np
+import torch
+import yaml
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+from ct_seg.denoise import tiffs
+from ct_seg.denoise.data import InferenceBatchSizeOptimizer, TomoDatasetInfer
+from ct_seg.denoise.model import unet_ns_gn
+
+warnings.filterwarnings("ignore")
+
+
+def main(args):
+    """Load the trained model and denoise the configured volume (or slice range)."""
+
+    # Read the YAML file
+    with open(args.config, "r") as file:
+        params = yaml.safe_load(file)
+
+    # setup output directory
+    output_dir = params["dataset"]["directory_to_reconstructions"] + "/" "denoised_volume"
+    if os.path.isdir(output_dir):
+        shutil.rmtree(output_dir)
+    os.mkdir(output_dir)
+
+    # setup cuda device
+    dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # load in model
+    path_to_mdl = (
+        params["dataset"]["directory_to_reconstructions"]
+        + "/"
+        + "TrainOutput"
+        + "/"
+        + "best_edge_model.pth"
+    )
+    # weights_only=True: restrict deserialization to tensors/containers.
+    # torch.load unpickles arbitrary Python by default, so a malicious
+    # checkpoint file would execute code on load (CWE-502 / bandit B614).
+    checkpoint = torch.load(path_to_mdl, map_location=torch.device("cpu"), weights_only=True)
+    model = unet_ns_gn(ich=5, start_filter_size=16, channels_per_group=8)
+    model.load_state_dict(checkpoint["model_state_dict"])
+    model.to(dev).eval()
+
+    print("\nLoading data into CPU memory, it will take a while ... ...")
+
+    # load in data
+    ds_test = TomoDatasetInfer(
+        params=params, start_slice=args.start_slice, end_slice=args.end_slice
+    )
+    print(
+        f"\nLoaded in {ds_test.reconstruction.shape[0]} slices of size {ds_test.reconstruction.shape[1]}x{ds_test.reconstruction.shape[2]}.\n"
+    )
+
+    # determine optimal batch size given GPU system memory, model size, and image size
+    optimal_batch_size = InferenceBatchSizeOptimizer(
+        model=model,
+        input_shape=ds_test.reconstruction[0].shape,
+        device=dev,
+        max_batch_size=16,
+        precision="fp32",
+    )
+    stats = optimal_batch_size.profile()
+    mbsz = stats["optimal_batch_size"]
+
+    dl_test = DataLoader(
+        dataset=ds_test,
+        batch_size=mbsz,
+        shuffle=False,
+        num_workers=4,
+        drop_last=False,
+        prefetch_factor=6,
+        pin_memory=True,
+    )
+
+    # initialize empty array for denoised volume
+    preds = np.zeros_like(dl_test.dataset.reconstruction)
+    insert_cnt = 0
+    # denoise volume
+    print("Processing data ...")
+    with torch.no_grad():
+        for X in tqdm(dl_test):
+            output = model(X.to(dev)).cpu().squeeze(dim=1).numpy()
+
+            preds[insert_cnt : (insert_cnt + X.shape[0])] = output
+            insert_cnt += X.shape[0]
+
+    # rescale volume
+    preds = preds * params["dataset"]["std4norm"] + params["dataset"]["mean4norm"]
+
+    # save volume
+    print("\nSaving data ...")
+    if len(args.start_slice) == 0:
+        tiffs.save_stack(output_dir, preds)
+    else:
+        # Save the processed sub volume with the right tiff number
+        tiffs.save_stack(output_dir, preds, offset=int(args.start_slice))
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(description="Inference for 2.5D Noise2Inverse")
+    parser.add_argument("-gpus", type=str, default="0", help="list of visiable GPUs")
+    parser.add_argument("-start_slice", type=str, default=0, help="minibatch size")
+    parser.add_argument("-end_slice", type=str, default=None, help="minibatch size")
+    parser.add_argument("-config", type=str, required=True, help="path to config yaml file")
+    parser.add_argument(
+        "-verbose", type=int, default=1, help="1:print to terminal; 0: redirect to file"
+    )
+
+    args, unparsed = parser.parse_known_args()
+
+    if len(unparsed) > 0:
+        print("Unrecognized argument(s): \n%s \nProgram exiting ... ... " % "\n".join(unparsed))
+        exit(0)
+
+    if len(args.gpus) > 0:
+        os.environ["CUDA_VISIBLE_DEVICES"] = args.gpus
+
+    logging.getLogger("matplotlib.font_manager").disabled = True
+    logging.getLogger("matplotlib").setLevel(level=logging.CRITICAL)
+    if args.verbose:
+        logging.getLogger().addHandler(logging.StreamHandler(sys.stdout))
+
+    start_time = time.time()
+    main(args)
+    inference_time = time.time() - start_time
+    print(f"\nInference Time: {inference_time:.4f} seconds\n")

ct_seg/denoise/eval.py

@@ -0,0 +1,94 @@
+"""
+eval.py — Laplacian-based edge/sharpness score for monitoring denoising quality.
+
+Provides `laplacian_score_batch`, the metric main.py uses during validation to
+track how sharp the denoised output is. For each image it measures edge contrast
+as the ratio of mean |Laplacian| in edge pixels to that in flat pixels; for very
+flat images (low Laplacian-histogram entropy) it instead rewards smoothness. A
+higher score means sharper, better-resolved edges, and main.py keeps the
+checkpoint with the highest score (best_edge_model.pth).
+
+Author:  Cameron Renteria <crentb23@gmail.com>
+License: Apache-2.0 (see LICENSE)
+"""
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+def laplacian_batch(x):
+    """Apply a 3x3 discrete Laplacian (edge) filter to a batch of images.
+
+    Args:
+        x: tensor [B, C, H, W]; the same kernel is applied per channel (grouped conv).
+    Returns:
+        The Laplacian response, same shape as `x`.
+    """
+    # x: [B, C, H, W] (assumes grayscale: C=1)
+    kernel = torch.tensor([[0, 1, 0], [1, -4, 1], [0, 1, 0]], dtype=x.dtype, device=x.device).view(
+        1, 1, 3, 3
+    )
+    kernel = kernel.repeat(x.shape[1], 1, 1, 1)  # for grouped conv
+    return F.conv2d(x, kernel, padding=1, groups=x.shape[1])
+
+
+def laplacian_entropy_map(lap, bins=256):
+    """Per-image Shannon entropy of the Laplacian-magnitude histogram.
+
+    Higher entropy means a busier (more textured/edge-rich) image. Returns a 1-D
+    tensor of length B, one value per image in the batch.
+    """
+    # Compute entropy for each image in batch
+    B = lap.shape[0]
+    entropies = []
+    for i in range(B):
+        hist = torch.histc(lap[i, 0], bins=bins, min=0, max=lap[i, 0].max())
+        hist = hist / hist.sum()
+        hist = hist + 1e-8  # avoid log(0)
+        entropy = -torch.sum(hist * torch.log(hist))
+        entropies.append(entropy.item())
+    return torch.tensor(entropies, device=lap.device)
+
+
+def laplacian_score_batch(batch, entropy_thresh=0.2, q=0.9):
+    """Mean edge-quality score over a batch (higher = sharper edges).
+
+    Args:
+        batch         : tensor [B, 1, H, W] of images to score.
+        entropy_thresh: below this Laplacian-histogram entropy an image is treated
+                        as "flat" and scored on smoothness instead of edge contrast.
+        q             : quantile that separates edge pixels from flat pixels.
+    Returns:
+        float : the mean per-image score across the batch.
+    """
+    # batch: [B, 1, H, W]
+    lap = torch.abs(laplacian_batch(batch))  # [B, 1, H, W]
+    B = lap.shape[0]
+    scores = []
+
+    entropies = laplacian_entropy_map(lap)
+
+    for i in range(B):
+        lap_i = lap[i, 0]  # [H, W]
+        entropy = entropies[i]
+
+        if entropy < entropy_thresh:
+            # flat image: reward smoothness
+            # score = -torch.mean(lap_i).item()
+            smoothness = 1.0 / (lap_i.mean().item() + 1e-6)
+            scores.append(smoothness)
+        else:
+            # compute threshold using quantile
+            threshold = torch.quantile(lap_i, q)
+            edge_mask = lap_i > threshold
+            flat_mask = ~edge_mask
+
+            edge_score = lap_i[edge_mask].mean() if edge_mask.any() else 0.0
+            flat_score = lap_i[flat_mask].mean() if flat_mask.any() else 1e-6  # prevent div 0
+
+            contrast = edge_score / (flat_score + 1e-6)
+            scores.append(contrast)
+
+    return float(np.mean(scores))
+    # return np.array(scores).astype(np.float32)

ct_seg/denoise/loss.py

@@ -0,0 +1,78 @@
+"""
+loss.py — Laplacian Contrast Loss (LCL) for edge-aware CT denoising.
+
+Defines the auxiliary loss used by main.py after the L1 warm-up. The Laplacian
+highlights edges; LCL compares the mean Laplacian magnitude of "edge" pixels (the
+top 20% by |Laplacian|) against "flat" pixels and returns flat/edge. Minimizing
+this ratio pushes the network to keep edges sharp (high Laplacian) while smoothing
+flat regions (low Laplacian), counteracting the over-smoothing that plain L1
+denoising tends to produce.
+
+Author:  Cameron Renteria <crentb23@gmail.com>
+License: Apache-2.0 (see LICENSE)
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def laplacian_batch(x):
+    """Apply a 3x3 discrete Laplacian (edge) filter to a batch of images.
+
+    Args:
+        x: tensor [B, C, H, W]; the same kernel is applied per channel (grouped conv).
+    Returns:
+        The Laplacian response, same shape as `x`.
+    """
+    # x: [B, C, H, W] (assumes grayscale: C=1)
+    kernel = torch.tensor([[0, 1, 0], [1, -4, 1], [0, 1, 0]], dtype=x.dtype, device=x.device).view(
+        1, 1, 3, 3
+    )
+    kernel = kernel.repeat(x.shape[1], 1, 1, 1)  # for grouped conv
+    return F.conv2d(x, kernel, padding=1, groups=x.shape[1])
+
+
+class LCL(nn.Module):
+    """Laplacian Contrast Loss (see module docstring).
+
+    forward(pred) returns flat_mean / (edge_mean + eps), where edge pixels are the
+    top 20% by |Laplacian| and flat pixels are the rest. Lower is better: it favors
+    sharp edges relative to flat regions.
+    """
+
+    def __init__(
+        self,
+    ):
+        super(LCL, self).__init__()
+
+    def forward(self, pred):
+        L = torch.abs(laplacian_batch(pred))
+        threshold = torch.quantile(L, 0.80)
+        # Split pixels into 'edge' (top 20% by Laplacian magnitude) and 'flat' (the rest).
+        edge_mask = L > threshold
+        flat_mask = ~edge_mask
+
+        edge_mean = L[edge_mask].mean() if edge_mask.any() else 0.0
+        flat_mean = L[flat_mask].mean() if flat_mask.any() else 1e-6
+
+        # Encourage this ratio to grow (i.e., minimize the inverse)
+        return flat_mean / (edge_mean + 1e-6)
+
+
+def laplacian_entropy_map(lap, bins=256):
+    """Per-image Shannon entropy of the Laplacian-magnitude histogram.
+
+    Higher entropy means a busier (more textured/edge-rich) image. Returns a 1-D
+    tensor of length B, one value per image in the batch.
+    """
+    # Compute entropy for each image in batch
+    B = lap.shape[0]
+    entropies = []
+    for i in range(B):
+        hist = torch.histc(lap[i, 0], bins=bins, min=0, max=lap[i, 0].max().item())
+        hist = hist / hist.sum()
+        hist = hist + 1e-8  # avoid log(0)
+        entropy = -torch.sum(hist * torch.log(hist))
+        entropies.append(entropy.item())
+    return torch.tensor(entropies, device=lap.device)

ct_seg/denoise/model.py

@@ -0,0 +1,205 @@
+"""
+model.py — U-Net architecture for 2.5D Noise2Inverse denoising.
+
+Defines a compact 2D U-Net used as the denoiser. The variant used by the project
+is `unet_ns_gn` ("no-skip, group-norm"): a U-Net WITHOUT the usual skip
+connections between encoder and decoder, using Group Normalization and LeakyReLU
+throughout. Empirically this no-skip design is a robust denoiser across different
+CT samples (skip connections tend to let high-frequency noise bypass the network).
+
+The network takes a stack of adjacent slices as input channels (5 for the 2.5D
+setup) and outputs a single denoised slice. Helper modules:
+    unet_box_gn        - double 3x3 conv block (conv -> GroupNorm -> LeakyReLU, x2)
+    unet_bottleneck_gn - single 3x3 conv block at the bottleneck
+    unet_down          - 2x2 max-pool downsampling
+    unet_up            - nearest-neighbour 2x upsampling
+    unet_ns_gn         - the full encoder/bottleneck/decoder network
+
+Author:  Cameron Renteria <crentb23@gmail.com>
+License: Apache-2.0 (see LICENSE)
+"""
+
+import torch
+import torch.nn as nn
+
+
+class unet_box_gn(torch.nn.Module):
+    """Double convolution block: (Conv3x3 -> GroupNorm -> LeakyReLU) applied twice.
+
+    Preserves spatial size (padding=1) while mapping `in_ch` -> `out_ch` channels.
+    `groups` sets the number of GroupNorm groups.
+    """
+
+    def __init__(self, in_ch, out_ch, groups):
+        super().__init__()
+        self.double_conv = torch.nn.Sequential(
+            torch.nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1),
+            nn.GroupNorm(num_groups=groups, num_channels=out_ch),
+            nn.LeakyReLU(0.1, inplace=True),
+            torch.nn.Conv2d(out_ch, out_ch, kernel_size=3, padding=1),
+            nn.GroupNorm(num_groups=groups, num_channels=out_ch),
+            nn.LeakyReLU(0.1, inplace=True),
+        )
+
+    def forward(self, x):
+        return self.double_conv(x)
+
+
+class unet_bottleneck_gn(torch.nn.Module):
+    """Single convolution block (Conv3x3 -> GroupNorm -> LeakyReLU) for the bottleneck."""
+
+    def __init__(self, in_ch, out_ch, groups):
+        super().__init__()
+        self.bn_conv = torch.nn.Sequential(
+            torch.nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1),
+            nn.GroupNorm(num_groups=groups, num_channels=out_ch),
+            nn.LeakyReLU(0.1, inplace=True),
+        )
+
+    def forward(self, x):
+        return self.bn_conv(x)
+
+
+class unet_up(torch.nn.Module):
+    """Upsampling block: nearest-neighbour 2x upsampling (no learned parameters).
+
+    The `ch` argument is accepted for interface symmetry but is unused.
+    """
+
+    def __init__(
+        self,
+        ch,
+    ):
+        super().__init__()
+        self.down_scale = torch.nn.Sequential(torch.nn.Upsample(scale_factor=2, mode="nearest"))
+
+    def forward(self, x):
+        return self.down_scale(x)
+
+
+class unet_down(torch.nn.Module):
+    """Downsampling block: 2x2 max pooling (halves the spatial resolution)."""
+
+    def __init__(self, ch):
+        super().__init__()
+        self.maxpool = torch.nn.Sequential(
+            torch.nn.MaxPool2d(2),
+        )
+
+    def forward(self, x):
+        return self.maxpool(x)
+
+
+class unet_ns_gn(torch.nn.Module):
+    """No-skip U-Net with Group Normalization (the project's denoiser).
+
+    Args:
+        start_filter_size : base channel width; deeper stages use multiples of it.
+        ich               : number of input channels (5 for 2.5D: five adjacent slices).
+        och               : number of output channels (1 = a single denoised slice).
+        channels_per_group: channels per GroupNorm group (sets num_groups internally).
+
+    The forward pass is a straight encoder -> bottleneck -> decoder with NO skip
+    connections; spatial resolution is restored purely by the upsampling stages.
+    """
+
+    def __init__(self, start_filter_size, ich=1, och=1, channels_per_group=8):
+        super().__init__()
+        # Stem: 1x1 conv lifting the `ich` input channels up to start_filter_size.
+        self.in_box = torch.nn.Sequential(
+            torch.nn.Conv2d(ich, start_filter_size, kernel_size=1, padding=0),
+            nn.GroupNorm(
+                num_groups=int((start_filter_size) / channels_per_group),
+                num_channels=start_filter_size,
+            ),
+            nn.LeakyReLU(0.1, inplace=True),
+        )
+        # --- Encoder: progressively widen channels and halve spatial size ---
+        self.box1 = unet_box_gn(
+            start_filter_size,
+            start_filter_size * 4,
+            groups=int((start_filter_size * 4) / channels_per_group),
+        )
+        self.down1 = unet_down(start_filter_size * 4)
+
+        self.box2 = unet_box_gn(
+            start_filter_size * 4,
+            start_filter_size * 8,
+            groups=int((start_filter_size * 8) / channels_per_group),
+        )
+        self.down2 = unet_down(start_filter_size * 8)
+
+        self.box3 = unet_box_gn(
+            start_filter_size * 8,
+            start_filter_size * 16,
+            groups=int((start_filter_size * 16) / channels_per_group),
+        )
+        self.down3 = unet_down(start_filter_size * 16)
+
+        # --- Bottleneck (lowest resolution) ---
+        self.bottleneck = unet_bottleneck_gn(
+            start_filter_size * 16,
+            start_filter_size * 16,
+            groups=int((start_filter_size * 16) / channels_per_group),
+        )
+
+        # --- Decoder: upsample back to full resolution (NO skip connections) ---
+        self.up1 = unet_up(start_filter_size * 16)
+        self.box4 = unet_box_gn(
+            start_filter_size * 16,
+            start_filter_size * 8,
+            groups=int((start_filter_size * 8) / channels_per_group),
+        )
+
+        self.up2 = unet_up(start_filter_size * 8)
+        self.box5 = unet_box_gn(
+            start_filter_size * 8,
+            start_filter_size * 4,
+            groups=int((start_filter_size * 4) / channels_per_group),
+        )
+
+        self.up3 = unet_up(start_filter_size * 4)
+        self.box6 = unet_box_gn(
+            start_filter_size * 4,
+            start_filter_size * 4,
+            groups=int((start_filter_size * 4) / channels_per_group),
+        )
+
+        # Output head: project down to `och` output channel(s).
+        self.out_layer = torch.nn.Sequential(
+            torch.nn.Conv2d(start_filter_size * 4, start_filter_size * 2, kernel_size=1, padding=0),
+            nn.GroupNorm(
+                num_groups=int((start_filter_size * 2) / channels_per_group),
+                num_channels=start_filter_size * 2,
+            ),
+            nn.LeakyReLU(0.1, inplace=True),
+            torch.nn.Conv2d(start_filter_size * 2, och, kernel_size=1, padding=0),
+        )
+
+    def forward(self, x):
+        output = self.in_box(x)
+
+        output = self.box1(output)
+        output = self.down1(output)
+
+        output = self.box2(output)
+        output = self.down2(output)
+
+        output = self.box3(output)
+        output = self.down3(output)
+
+        output = self.bottleneck(output)
+
+        output = self.up1(output)
+
+        output = self.box4(output)
+        output = self.up2(output)
+
+        output = self.box5(output)
+        output = self.up3(output)
+
+        output = self.box6(output)
+
+        output = self.out_layer(output)
+
+        return output

ct_seg/denoise/tiffs.py

@@ -0,0 +1,105 @@
+"""
+tiffs.py — TIFF stack input/output helpers for CT volumes.
+
+Utilities for reading and writing the TIFF image stacks that make up a CT
+reconstruction: natural (human) sorting of filenames, loading a directory of TIFFs
+into a NumPy volume, globbing a directory for TIFFs, saving a volume back out as
+numbered TIFFs, and loading a stack as a sinogram.
+
+Author:  Cameron Renteria <crentb23@gmail.com>
+License: Apache-2.0 (see LICENSE)
+"""
+
+import re
+from pathlib import Path
+
+import numpy as np
+import tifffile
+from tqdm import tqdm
+
+
+def natural_sorted(paths):
+    """Sort paths/strings in natural (human) order so that e.g. img2 precedes img10."""
+
+    def key(x):
+        return [int(c) if c.isdigit() else c for c in re.split("([0-9]+)", str(x))]
+
+    return sorted(paths, key=key)
+
+
+# We use the following function to load a stack of images:
+def load_stack(paths, binning=1, use_tqdm=True):
+    """Load a stack of tiff files.
+
+    :param paths: paths to tiff files
+    :param binning: whether angles and projection images should be binned.
+    :returns: an np.array containing the values in the tiff files
+    :rtype: np.array
+
+    """
+    # Read first image for shape and dtype information
+    paths = list(paths)
+
+    img0 = tifffile.imread(str(paths[0]))
+    img0 = img0[::binning, ::binning]
+    dtype = img0.dtype
+    # Create empty numpy array to hold result
+    imgs = np.empty((len(paths), *img0.shape), dtype=dtype)
+
+    for i in tqdm(range(len(paths))):
+        imgs[i] = tifffile.imread(str(paths[i]))[::binning, ::binning]
+    return imgs
+
+
+def glob(dir_path):
+    """Expand path to list of all tiffs in directory
+
+    :param dir_path: directory
+    :returns:
+    :rtype:
+
+    """
+    dir_path = Path(dir_path).expanduser().resolve()
+    return natural_sorted(dir_path.glob("*.tif*"))
+
+
+def save_stack(path, stack, offset=0, exist_ok=True, parents=False):
+    """Write a 3-D volume to `path` as zero-padded numbered TIFFs (NNNNN.tiff).
+
+    `offset` shifts the starting file number so a denoised sub-range keeps the same
+    indices as the original slices.
+    """
+    path = Path(path).expanduser().resolve()
+    path.mkdir(exist_ok=exist_ok, parents=parents)
+    for i in tqdm(range(stack.shape[0])):
+        opath = path / f"{i+offset:05d}.tiff"
+        tifffile.imwrite(str(opath), stack[i])
+
+
+def load_sino(paths, binning=1, dtype=None, flip_y=False):
+    """Load a stack of tiff files into a sinogram
+
+    :param paths: paths to tiff files
+    :param binning: whether angles and projection images should be binned.
+    :returns: an np.array containing the values in the tiff files
+    :rtype: np.array
+
+    """
+    # Read first image for shape and dtype information
+    paths = list(paths)
+    # print(paths[0])
+    # sys.exit()
+    img0 = tifffile.imread(str(paths[0]))
+    img0 = img0[::binning, ::binning]
+    if dtype is None:
+        dtype = img0.dtype
+    # Create empty numpy array to hold result
+    imgs = np.empty((img0.shape[0], len(paths), img0.shape[1]), dtype=dtype)
+    for i, p in tqdm(enumerate(paths)):
+        # Angles in the middle, "up" in front, "right" at the back.
+        if flip_y:
+            # Flip in the vertical direction
+            imgs[:, i, :] = tifffile.imread(str(p))[::-binning, ::binning]
+        else:
+            imgs[:, i, :] = tifffile.imread(str(p))[::binning, ::binning]
+    return imgs