ifsegment 0.0.1__tar.gz

ifsegment-0.0.1/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: ifsegment
+Version: 0.0.1
+Summary: Cell segmentation and protein quantification from immunofluorescence images
+Author: Chris Viets
+Project-URL: Homepage, https://github.com/cviets/ifsegment
+Project-URL: Bug Tracker, https://github.com/cviets/ifsegment/issues
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: aicspylibczi>=3.1.1
+Requires-Dist: tqdm
+Requires-Dist: scikit-image
+Requires-Dist: scipy

ifsegment-0.0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ifsegment"
+version = "0.0.1"
+description = "Cell segmentation and protein quantification from immunofluorescence images"
+readme = "README.md"
+requires-python = ">=3.6"
+authors = [
+    { name = "Chris Viets" }
+]
+dependencies = [
+    "numpy",
+    "aicspylibczi>=3.1.1",
+    # "aicsimageio @ git+https://github.com/cviets/aicsimageio@main",
+    "tqdm",
+    "scikit-image",
+    "scipy"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/cviets/ifsegment"
+"Bug Tracker" = "https://github.com/cviets/ifsegment/issues"
+
+[project.scripts]
+ifsegment = "ifsegment.cli:main"

ifsegment-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ifsegment-0.0.1/src/ifsegment/cli.py

@@ -0,0 +1,33 @@
+import argparse
+from .run_cyto_mask import main as cyto_main
+from .run_mask import main as mask_main
+from .run_quant import main as quant_main
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="ifsegment", 
+        description="Cell segmentation from IF images", 
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+        )
+    subparsers = parser.add_subparsers(dest="command", required=False)
+
+    mask_parser = subparsers.add_parser("mask", help="Generate nuclear and cytoplasmic masks", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    mask_parser.add_argument("-i", "--input", type=str, required=True, help="Path to directory with .czi images")
+    mask_parser.add_argument("-o", "--output", type=str, required=True, help="Path to directory to save masks")
+    mask_parser.add_argument("-n", "--nuclear", type=int, default=0, help="Nuclear channel number (0-indexed)")
+    mask_parser.add_argument("-c", "--cytoplasmic", type=int, default=3, help="Cytoplasmic channel number (0-indexed)")
+    mask_parser.add_argument("-m", "--mode", type=str, default="max", help="z-projection type (choose from 'max' or 'mean')")
+
+    quant_parser = subparsers.add_parser("quantify", help="Quantify protein fluorescence in nucleus and cytoplasm", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    quant_parser.add_argument("-i", "--input", type=str, required=True, help="Path to CZI images")
+    quant_parser.add_argument("-m", "--masks", type=str, required=True, help="Path to mask tiff files")
+    quant_parser.add_argument("-o", "--output", type=str, required=True, help="Path to output CSV file to store data")
+    quant_parser.add_argument("-c", "--channels", type=int, nargs="+", default=[1, 2], help="Channel numbers to quantify (0-indexed)")
+    quant_parser.add_argument("-md", "--mode", type=str, default="max", help="z-projection type (choose from 'max' or 'mean')")
+
+    args = parser.parse_args()
+    
+    if args.command == "mask":
+        mask_main(args.input, args.output, args.nuclear, args.cytoplasmic, args.mode)
+    elif args.command == "quantify":
+        quant_main(args.input, args.masks, args.output, args.channels, args.mode)

ifsegment-0.0.1/src/ifsegment/modules/cyto_segment.py

@@ -0,0 +1,66 @@
+import numpy as np
+from .io_utils import read_czi, get_czi_in_folder, write_tiff, get_well_from_file
+from .normalizations import minmax_percentile, clip_512, zstack
+from aicsimageio import AICSImage
+from tqdm import tqdm
+from skimage.morphology import remove_small_objects, remove_small_holes, diamond
+from skimage.measure import label
+from scipy.ndimage import binary_closing, binary_dilation, binary_erosion
+
+def cyto_segment_array(image: np.ndarray[np.float64]) -> np.ndarray[np.bool_]:
+    """
+    Create cytoplasmic segmentation of input 2D image
+
+    Parameters 
+    -----------
+    image: np.ndarray[np.float64]
+        Input image as numpy array
+    
+    Returns 
+    -----------
+    mask : np.ndarray[np.bool_]
+        Mask of image
+    """
+    assert image.ndim == 2
+
+    # we are interested in the non-one values 
+    # (want to ignore super outlier-y bright spots)
+    mu = np.mean(image[image < 1])
+    std = np.std(image[image < 1])
+
+    # hard coded: mask according to mean +/- 5 std for non-bright spots
+    thresh = min(0.75, mu + 5*std)
+    mask = image > thresh
+
+    diamond_strel = diamond(1)
+    mask = binary_dilation(mask, diamond_strel, iterations=3)
+    mask = remove_small_holes(mask, 1200, connectivity=2)
+    mask = binary_erosion(mask, diamond_strel, iterations=3)
+
+    mask = remove_small_objects(mask, min_size=600, connectivity=2)
+    
+    return mask
+
+def czi_preprocess(czi_image: AICSImage, cyto_channel: int, mode:str="max") -> np.ndarray[np.float64]: 
+
+    img_dask = czi_image.get_image_dask_data("ZYX", T=0, C=cyto_channel)
+    img_numpy = img_dask.compute()
+    img_numpy = zstack(img_numpy, 0, mode)
+    
+    # HARD CODED: normalize 0 percentile to -1 and 95 percentile to 1
+    img_numpy = clip_512(img_numpy)
+    img_numpy = minmax_percentile(img_numpy, 0, 95)
+    return img_numpy
+
+def cyto_segment_czi(czi_image: AICSImage, cyto_channel: int, mode:str="max") -> np.ndarray[np.bool_]:
+    preprocessed = czi_preprocess(czi_image, cyto_channel, mode)
+    return cyto_segment_array(preprocessed)
+
+def cyto_segment_folder(path_to_folder: str, output_folder:str, cyto_channel: int, mode:str="max") -> None:
+    czi_paths = get_czi_in_folder(path_to_folder)
+    for czi_path in tqdm(czi_paths, desc="Cytoplasm masks"):
+        img = read_czi(czi_path)
+        well_name = get_well_from_file(czi_path)
+        mask = cyto_segment_czi(img, cyto_channel, mode)
+        
+        write_tiff(mask, output_folder, well_name)

ifsegment-0.0.1/src/ifsegment/modules/io_utils.py

@@ -0,0 +1,69 @@
+from aicsimageio import AICSImage
+import os
+from glob import glob
+import re
+import tifffile
+import numpy as np
+from typing import List, Union
+import csv
+
+def read_czi(path_to_file: str) -> AICSImage:
+    return AICSImage(path_to_file)
+
+def read_tiff(path_to_file: str) -> Union[np.ndarray[np.float64], np.ndarray[np.bool_]]:
+    return tifffile.imread(path_to_file)
+
+def get_czi_in_folder(path_to_folder: str) -> List[str]:
+    """
+    Given a folder path, returns all CZI files in that folder
+    """
+    path_to_folder = os.path.expanduser(path_to_folder)
+    return glob(os.path.join(path_to_folder, "*.czi"))
+
+def get_well_from_file(filename: str) -> str:
+    """
+    Given an input file name (auto-generated by CZI software), returns well name
+
+    Parameters
+    ----------
+    filename : str
+        Path to input czi file
+
+    Returns
+    ---------
+    well : str
+        Name of well specified in file name
+    """
+    pattern = r"\.czi"
+    match = re.search(pattern, filename)
+    idx = match.start() - 3
+    return filename[idx:match.start()]
+
+def write_tiff(data: np.ndarray, output_dir: str, file_name: str) -> None:
+    output_dir = os.path.expanduser(output_dir)
+    if not os.path.isdir(output_dir):
+        os.mkdir(output_dir)
+    full_file = os.path.join(output_dir, file_name+".tiff")
+    tifffile.imwrite(full_file, data)
+
+def get_mask_path(path_to_masks, well_name):
+    masks = glob(os.path.join(path_to_masks, "*.tiff"))
+    for mask in masks:
+        head, tail = os.path.split(mask)
+        if well_name in tail:
+            return mask
+        
+    raise FileNotFoundError(f"No mask for well {well_name} found")
+
+def write_to_csv(data, path_to_csv):
+    base, ext = os.path.splitext(path_to_csv)
+    if ext != ".csv":
+        if ext == "" and os.path.isdir(base):
+            path_to_csv = os.path.join(path_to_csv, "ifsegment_data.csv")
+        else:
+            path_to_csv = base + ".csv"
+
+    with open(path_to_csv, newline='', mode='w') as csvfile:
+        writer = csv.writer(csvfile)
+        for row in data:
+            writer.writerow([str(elt) for elt in row])

ifsegment-0.0.1/src/ifsegment/modules/normalizations.py

@@ -0,0 +1,48 @@
+import numpy as np
+
+def minmax(inp):
+
+    if inp.ndim > 2:
+        return np.array([minmax(elt) for elt in inp])
+    
+    min_new = -1
+    max_new = 1
+
+    original_min = np.min(inp)
+    original_max = np.max(inp)
+    original_range = original_max - original_min
+
+    new_range = max_new - min_new
+
+    if original_range == 0:
+        return inp
+
+    return ((inp - original_min) / original_range) * new_range + min_new
+
+def minmax_percentile(inp, pmin, pmax):
+    if inp.ndim > 2:
+        return np.array([minmax_percentile(elt, pmin, pmax) for elt in inp])
+
+    min_val = np.percentile(inp, pmin)
+    max_val = np.percentile(inp, pmax)
+    clipped = np.clip(inp, min_val, max_val)
+    return minmax(clipped)
+
+def clip_512(inp):
+    if inp.ndim > 2:
+        return np.array([clip_512(elt) for elt in inp])
+    min_val = 512
+    max_val = np.max(inp)
+    return np.clip(inp, min_val, max_val)
+
+def zstack(image, axis, mode):
+    mode = mode.lower()
+    assert mode in {"max", "average", "avg", "mean"}
+
+    # take z-stack
+    if mode == "max":
+        out = np.max(image, axis=axis)
+    else:
+        out = np.mean(image, axis=axis)
+
+    return out

ifsegment-0.0.1/src/ifsegment/modules/nucleus_segment.py

@@ -0,0 +1,163 @@
+from .cyto_segment import cyto_segment_czi
+from aicsimageio import AICSImage
+import numpy as np
+from .normalizations import minmax_percentile, clip_512, zstack
+from .io_utils import get_czi_in_folder, read_czi, get_well_from_file, write_tiff
+from tqdm import tqdm
+from skimage.measure import label, regionprops
+from skimage.morphology import remove_small_objects, remove_small_holes, diamond
+from skimage.segmentation import find_boundaries
+from typing import Tuple
+import copy
+from scipy.ndimage import distance_transform_edt
+from scipy.ndimage import binary_closing
+
+def nucleus_preprocess(czi_image: AICSImage, nuclear_channel: int, cyto_channel: int, mode:str) -> np.ndarray[np.bool_]:
+    """
+    Generates nuclear mask from input AICS Image (from read_czi)
+
+    Parameters 
+    -----------
+    czi_image : AICSImage
+        AICSImage object containing CZI image information
+    nuclear_channel : int
+        Nuclear marker channel number (0-indexed) (eg, Hoechst)
+    cyto_channel : int
+        Cytoplasmic marker channel number (0-indexed), used to mask nuclei with associated cytoplasm
+
+    Returns
+    ---------
+    masks : np.ndarray[np.bool_]
+        Segmentation array containing cytoplasmic and nuclear masks
+    """
+
+    cyto_mask = cyto_segment_czi(czi_image, cyto_channel, mode)
+
+    img_dask = czi_image.get_image_dask_data("ZYX", T=0, C=nuclear_channel)
+    img_numpy = img_dask.compute()
+    img_numpy = zstack(img_numpy, axis=0, mode=mode)
+
+    # HARD CODED: normalize 0 percentile to -1 and 98 percentile to 1
+    img_numpy = clip_512(img_numpy)
+    img_numpy = minmax_percentile(img_numpy, 0, 98)
+
+    return img_numpy, cyto_mask
+
+def nuc_segment_array(
+        image: np.ndarray[np.float64], 
+        cyto_mask: np.ndarray[np.bool_]
+        ) -> Tuple[np.ndarray[np.bool_], int]:
+    """
+    Create nuclear segmentation of input 2D image 
+
+    Parameters 
+    -----------
+    image: np.ndarray[np.float64]
+        Input image as numpy array
+    cyto_mask: np.ndarray[np.bool_]
+        Cytoplasm mask (used to determine valid nuclei)
+    
+    Returns 
+    -----------
+    mask_out : np.ndarray[np.bool_]
+        Mask of image
+    num_cells: int
+        Number of nuclei counted
+    """
+
+    assert image.ndim == 2
+
+    # we are interested in the non-one values 
+    # (want to ignore super outlier-y bright spots)
+    mu = np.mean(image[image < 1])
+    std = np.std(image[image < 1])
+
+    # hard coded: mask according to mean +/- 5 std for non-bright spots
+    thresh = min(0, mu + 5*std)
+    mask = image > thresh
+
+    mask = remove_small_objects(mask, min_size=300, connectivity=2)
+    # mask = remove_small_holes(mask, 1200, connectivity=2)
+
+    # remove nuclei not touching cell cytoplasm (usually means no neurites)
+    cyto_dt = distance_transform_edt(~cyto_mask)
+    mask_out = np.zeros_like(mask, dtype=np.bool_)
+
+    labeled_nuclei = label(mask)
+    regions = regionprops(labeled_nuclei)
+    num_cells = 0
+    for region in tqdm(regions, desc="Validating nuclei"):
+
+        cur_nucleus = region.image
+        boundary = find_boundaries(cur_nucleus, mode="outer")
+        temp_dt = cyto_dt[region.slice]
+        _temp_dt = copy.deepcopy(temp_dt)
+        temp_dt[~boundary] = -1
+        distances = temp_dt[temp_dt != -1]
+
+        # majority rules
+        if len(distances[distances==0]) >= 0.5 * len(distances):
+            num_cells += 1
+            mask_out[region.slice] = cur_nucleus
+
+        cyto_dt[region.slice] = _temp_dt
+    
+    mask_out = binary_closing(mask_out, diamond(1), iterations=1)
+    mask_out = remove_small_holes(mask_out, 100, connectivity=2)
+    return mask_out, num_cells
+
+def remove_unconnected_cyto(cyto_mask:np.ndarray[np.bool_], nuc_mask: np.ndarray[np.bool_]) -> np.ndarray[np.bool_]:
+    """
+    Remove cytoplasmic objects not touching or overlapping nuclear objects
+    """
+    mask_out = np.zeros_like(cyto_mask)
+    labeled_cyto = label(cyto_mask)
+    regions = regionprops(labeled_cyto)
+    nuc_dt = distance_transform_edt(~nuc_mask)
+    for region in tqdm(regions, desc="Validating cytoplasm"):
+
+        cur_cyto = region.image
+        temp_dt = nuc_dt[region.slice]
+        _temp_dt = copy.deepcopy(temp_dt)
+        temp_dt[~cur_cyto] = -1
+        distances = temp_dt[temp_dt != -1]
+
+        if min(distances) <= 1:
+            mask_out[region.slice] = cur_cyto
+
+        nuc_dt[region.slice] = _temp_dt
+
+    return mask_out
+
+def fill_holes_trinary(trinary_mask):
+    binary_mask = trinary_mask > 0
+    binary_mask_filled = remove_small_holes(binary_mask, 200)
+    holes = np.logical_and(binary_mask_filled, ~binary_mask)
+    mask_out = trinary_mask
+    mask_out[holes] = 2
+    return mask_out
+
+def segment_folder(path_to_folder: str, output_folder: str, nuclear_channel: int, cyto_channel: int, mode:str) -> None:
+    czi_paths = get_czi_in_folder(path_to_folder)
+    cell_counts = [None]*len(czi_paths)
+    for i, czi_path in enumerate(tqdm(czi_paths, desc="Masking cells")):
+        img = read_czi(czi_path)
+        well_name = get_well_from_file(czi_path)
+        preprocessed_img, cyto_mask = nucleus_preprocess(img, nuclear_channel, cyto_channel, mode)
+        write_tiff(preprocessed_img, output_folder, well_name + "_PREPROCESSED_NUC")
+        nuc_mask, num_cells = nuc_segment_array(preprocessed_img, cyto_mask)
+        cyto_mask = remove_unconnected_cyto(cyto_mask, nuc_mask)
+        mask = np.zeros_like(nuc_mask, dtype=np.float64)
+
+        # trinary image: nuc = 1, cyto = 2
+        mask[cyto_mask] = 2
+        # nuc_mask should override cyto_mask
+        mask[nuc_mask] = 1
+
+        mask = fill_holes_trinary(mask)
+        
+        write_tiff(mask, output_folder, well_name)
+        cell_counts[i] = num_cells
+
+    return cell_counts
+        

ifsegment-0.0.1/src/ifsegment/modules/protein_quantification.py

@@ -0,0 +1,89 @@
+import numpy as np
+from typing import Tuple, List
+from .io_utils import get_czi_in_folder, get_well_from_file, get_mask_path, read_czi, read_tiff, write_to_csv
+from .normalizations import zstack
+from tqdm import tqdm
+
+def quantify_channels(image: np.ndarray[np.float64], mask: np.ndarray[np.float64]) -> Tuple[np.ndarray[np.bool_]]:
+    """
+    Quantify nuclear and cytoplasmic protein fluorescence
+
+    Parameters 
+    -----------
+    image : np.ndarray[np.float64]
+        Input image as numpy array (CYX with C containing channels of interest)
+    mask : np.ndarray[np.float64]
+        Trinary mask (2D array, YX, 0 = background, 1 = nucleus, 2 = cytoplasm)
+
+    Returns 
+    -----------
+    fluor : np.ndarray[np.float64]
+        C-by-3 array containing [total, nuclear, cytoplasmic] fluorescence for each protein
+    """
+    # NOTE: it is important not to modify the pixel values in the image itself since we don't want to mess with the data
+    nuc_mask = mask==1
+    cyto_mask = mask==2
+
+    if image.ndim == 2:
+        image = np.expand_dims(image, 0)
+
+    fluor = np.zeros(shape=(len(image), 3))
+
+    # compute mean intensities for each channel
+    for i, channel in enumerate(image):
+        fluor[i, 0] = np.mean(channel[np.logical_or(nuc_mask, cyto_mask)])
+        fluor[i, 1] = np.mean(channel[nuc_mask])
+        fluor[i, 2] = np.mean(channel[cyto_mask])
+
+    return fluor
+
+def quantify_folder(path_to_images: str, path_to_masks: str, path_to_save: str, channels: List[int], mode:str):
+    """
+    Parameters 
+    -----------
+    path_to_images : str
+        Path to czi images
+    path_to_masks : str
+        Path to tiff trinary masks
+    path_to_save : str
+        Path to save data (CSV file)
+    channels : List[int]
+        List of channel indices (0-indexed) to quantify fluorescence
+    mode : str
+        Mode for z-projecting (max or mean)
+    
+    Returns 
+    -----------
+    None
+    """
+    image_paths = get_czi_in_folder(path_to_images)
+
+    # for each channel, we measure total, nuclear, cytoplasmic, and N/C ratio
+    data = np.zeros(shape=(len(image_paths), 1+4*len(channels)),dtype=object)
+    
+    for idx, image_path in enumerate(tqdm(image_paths, desc="Measuring all images")):
+        well_name = get_well_from_file(image_path)
+        mask_path = get_mask_path(path_to_masks, well_name)
+        image_czi = read_czi(image_path)
+        image_dask = image_czi.get_image_dask_data("CZYX", C=channels)
+        image_numpy = image_dask.compute()
+        image = zstack(image_numpy, 1, mode)
+        mask = read_tiff(mask_path)
+        data[idx, 0] = well_name
+
+        fluor = quantify_channels(image, mask)
+        for idx_j in range(len(channels)):
+            total = fluor[idx_j, 0]
+            nuclear = fluor[idx_j, 1]
+            cytoplasmic = fluor[idx_j, 2]
+            data[idx, 4*idx_j+1] = total
+            data[idx, 4*idx_j+2] = nuclear
+            data[idx, 4*idx_j+3] = cytoplasmic
+            data[idx, 4*idx_j+4] = nuclear/cytoplasmic
+
+    header = ["Well"]
+    for channel in channels:
+        channel_string = "Ch"+str(channel)
+        header += [channel_string+"_TOT", channel_string+"_N", channel_string+"_C", channel_string+"_N/C"]
+    data = np.vstack((header, data))
+    write_to_csv(data, path_to_save)

ifsegment-0.0.1/src/ifsegment/run_cyto_mask.py

@@ -0,0 +1,4 @@
+from .modules.cyto_segment import cyto_segment_folder
+
+def main(input, output, channel):
+    return cyto_segment_folder(input, output, channel)

ifsegment-0.0.1/src/ifsegment/run_mask.py

@@ -0,0 +1,4 @@
+from .modules.nucleus_segment import segment_folder
+
+def main(input, output, channel_n, channel_c, mode):
+    return segment_folder(input, output, channel_n, channel_c, mode)

ifsegment-0.0.1/src/ifsegment/run_quant.py

@@ -0,0 +1,6 @@
+from .modules.protein_quantification import quantify_folder
+
+def main(input, masks, output, channels, mode):
+    if isinstance(channels, int):
+        channels = [channels]
+    quantify_folder(input, masks, output, channels, mode)

ifsegment-0.0.1/src/ifsegment.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: ifsegment
+Version: 0.0.1
+Summary: Cell segmentation and protein quantification from immunofluorescence images
+Author: Chris Viets
+Project-URL: Homepage, https://github.com/cviets/ifsegment
+Project-URL: Bug Tracker, https://github.com/cviets/ifsegment/issues
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: aicspylibczi>=3.1.1
+Requires-Dist: tqdm
+Requires-Dist: scikit-image
+Requires-Dist: scipy

ifsegment-0.0.1/src/ifsegment.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+pyproject.toml
+src/ifsegment/__init__.py
+src/ifsegment/cli.py
+src/ifsegment/run_cyto_mask.py
+src/ifsegment/run_mask.py
+src/ifsegment/run_quant.py
+src/ifsegment.egg-info/PKG-INFO
+src/ifsegment.egg-info/SOURCES.txt
+src/ifsegment.egg-info/dependency_links.txt
+src/ifsegment.egg-info/entry_points.txt
+src/ifsegment.egg-info/requires.txt
+src/ifsegment.egg-info/top_level.txt
+src/ifsegment/modules/cyto_segment.py
+src/ifsegment/modules/io_utils.py
+src/ifsegment/modules/normalizations.py
+src/ifsegment/modules/nucleus_segment.py
+src/ifsegment/modules/protein_quantification.py
+tests/test_file_io.py

ifsegment-0.0.1/src/ifsegment.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ifsegment-0.0.1/src/ifsegment.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ifsegment = ifsegment.cli:main

ifsegment-0.0.1/src/ifsegment.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy
+aicspylibczi>=3.1.1
+tqdm
+scikit-image
+scipy

ifsegment-0.0.1/src/ifsegment.egg-info/top_level.txt

@@ -0,0 +1 @@
+ifsegment

ifsegment-0.0.1/tests/test_file_io.py

@@ -0,0 +1,20 @@
+from src.ifsegment.modules.io_utils import read_czi, get_well_from_file, get_czi_in_folder
+import numpy as np
+
+def test_read_czi(inp, save_to):
+    img = read_czi(inp)
+    print(type(img), img.shape)
+    np.save(save_to, img)
+
+def test_well_from_file(filename):
+    print(get_well_from_file(filename))
+
+def test_get_czi_from_folder(path_to_czi_files):
+    return get_czi_in_folder(path_to_czi_files)
+
+def main():
+    path = "/media/cviets/Chris2/Exp008J-01"
+    return test_get_czi_from_folder(path)
+
+if __name__ == '__main__':
+    print(main())