PyNutil 0.1__py3-none-any.whl

PyNutil/__init__.py

@@ -0,0 +1 @@
+from .main import PyNutil

PyNutil/coordinate_extraction.py

@@ -0,0 +1,352 @@
+import numpy as np
+import pandas as pd
+from .read_and_write import load_visualign_json
+from .counting_and_load import flat_to_dataframe
+from .visualign_deformations import triangulate, transform_vec
+from glob import glob
+import cv2
+from skimage import measure
+import threading
+import re
+from .reconstruct_dzi import reconstruct_dzi
+
+
+def number_sections(filenames, legacy=False):
+    """
+    returns the section numbers of filenames
+
+    :param filenames: list of filenames
+    :type filenames: list[str]
+    :return: list of section numbers
+    :rtype: list[int]
+    """
+    filenames = [filename.split("\\")[-1] for filename in filenames]
+    section_numbers = []
+    for filename in filenames:
+        if not legacy:
+            match = re.findall(r"\_s\d+", filename)
+            if len(match) == 0:
+                raise ValueError(f"No section number found in filename: {filename}")
+            if len(match) > 1:
+                raise ValueError(
+                    "Multiple section numbers found in filename, ensure only one instance of _s### is present, where ### is the section number"
+                )
+            section_numbers.append(int(match[-1][2:]))
+        else:
+            match = re.sub("[^0-9]", "", filename)
+            ###this gets the three numbers closest to the end
+            section_numbers.append(match[-3:])
+    if len(section_numbers) == 0:
+        raise ValueError("No section numbers found in filenames")
+    return section_numbers
+
+
+# related to coordinate_extraction
+def get_centroids_and_area(segmentation, pixel_cut_off=0):
+    """This function returns the center coordinate of each object in the segmentation.
+    You can set a pixel_cut_off to remove objects that are smaller than that number of pixels.
+    """
+    labels = measure.label(segmentation)
+    # This finds all the objects in the image
+    labels_info = measure.regionprops(labels)
+    # Remove objects that are less than pixel_cut_off
+    labels_info = [label for label in labels_info if label.area > pixel_cut_off]
+    # Get the centre points of the objects
+    centroids = np.array([label.centroid for label in labels_info])
+    # Get the area of the objects
+    area = np.array([label.area for label in labels_info])
+    # Get the coordinates for all the pixels in each object
+    coords = np.array([label.coords for label in labels_info], dtype=object)
+    return centroids, area, coords
+
+
+# related to coordinate extraction
+def transform_to_registration(seg_height, seg_width, reg_height, reg_width):
+    """This function returns the scaling factors to transform the segmentation to the registration space."""
+    y_scale = reg_height / seg_height
+    x_scale = reg_width / seg_width
+    return y_scale, x_scale
+
+# related to coordinate extraction
+def find_matching_pixels(segmentation, id):
+    """This function returns the Y and X coordinates of all the pixels in the segmentation that match the id provided."""
+    mask = segmentation == id
+    mask = np.all(mask, axis=2)
+    id_positions = np.where(mask)
+    id_y, id_x = id_positions[0], id_positions[1]
+    return id_y, id_x
+
+
+# related to coordinate extraction
+def scale_positions(id_y, id_x, y_scale, x_scale):
+    """This function scales the Y and X coordinates to the registration space.
+    (The y_scale and x_scale are the output of transform_to_registration.)
+    """
+    id_y = id_y * y_scale
+    id_x = id_x * x_scale
+    return id_y, id_x
+
+
+# related to coordinate extraction
+def transform_to_atlas_space(anchoring, y, x, reg_height, reg_width):
+    """Transform to atlas space using the QuickNII anchoring vector."""
+    o = anchoring[0:3]
+    u = anchoring[3:6]
+    # Swap order of U
+    u = np.array([u[0], u[1], u[2]])
+    v = anchoring[6:9]
+    # Swap order of V
+    v = np.array([v[0], v[1], v[2]])
+    # Scale X and Y to between 0 and 1 using the registration width and height
+    y_scale = y / reg_height
+    x_scale = x / reg_width
+    xyz_v = np.array([y_scale * v[0], y_scale * v[1], y_scale * v[2]])
+    xyz_u = np.array([x_scale * u[0], x_scale * u[1], x_scale * u[2]])
+    o = np.reshape(o, (3, 1))
+    return (o + xyz_u + xyz_v).T
+
+
+# points.append would make list of lists, keeping sections separate.
+
+
+# related to coordinate extraction
+# This function returns an array of points
+def folder_to_atlas_space(
+    folder,
+    quint_alignment,
+    atlas_labels,
+    pixel_id=[0, 0, 0],
+    non_linear=True,
+    method="all",
+    object_cutoff=0,
+    atlas_volume=None,
+    use_flat=False,
+):
+    """Apply Segmentation to atlas space to all segmentations in a folder."""
+    """Return pixel_points, centroids, points_len, centroids_len, segmentation_filenames, """
+    # This should be loaded above and passed as an argument
+    slices = load_visualign_json(quint_alignment)
+
+    segmentation_file_types = [".png", ".tif", ".tiff", ".jpg", ".jpeg", ".dzip"]
+    segmentations = [
+        file
+        for file in glob(folder + "/segmentations/*")
+        if any([file.endswith(type) for type in segmentation_file_types])
+    ]
+    if len(segmentations) == 0:
+        raise ValueError(
+            f"No segmentations found in folder {folder}. Make sure the folder contains a segmentations folder with segmentations."
+        )
+    print(f"Found {len(segmentations)} segmentations in folder {folder}")
+    if use_flat == True:
+        flat_files = [
+            file
+            for file in glob(folder + "/flat_files/*")
+            if any([file.endswith(".flat"), file.endswith(".seg")])
+        ]
+        print(f"Found {len(flat_files)} flat files in folder {folder}")
+        flat_file_nrs = [int(number_sections([ff])[0]) for ff in flat_files]
+
+    # Order segmentations and section_numbers
+    # segmentations = [x for _,x in sorted(zip(section_numbers,segmentations))]
+    # section_numbers.sort()
+    points_list = [np.array([])] * len(segmentations)
+    centroids_list = [np.array([])] * len(segmentations)
+    region_areas_list = [
+        pd.DataFrame(
+            {
+                "idx": [],
+                "name": [],
+                "r": [],
+                "g": [],
+                "b": [],
+                "region_area": [],
+                "pixel_count": [],
+                "object_count": [],
+                "area_fraction": [],
+            }
+        )
+    ] * len(segmentations)
+    threads = []
+    for segmentation_path, index in zip(segmentations, range(len(segmentations))):
+        seg_nr = int(number_sections([segmentation_path])[0])
+        current_slice_index = np.where([s["nr"] == seg_nr for s in slices])
+        current_slice = slices[current_slice_index[0][0]]
+        if current_slice["anchoring"] == []:
+            continue
+        if use_flat == True:
+            current_flat_file_index = np.where([f == seg_nr for f in flat_file_nrs])
+            current_flat = flat_files[current_flat_file_index[0][0]]
+        else:
+            current_flat = None
+
+        x = threading.Thread(
+            target=segmentation_to_atlas_space,
+            args=(
+                current_slice,
+                segmentation_path,
+                atlas_labels,
+                current_flat,
+                pixel_id,
+                non_linear,
+                points_list,
+                centroids_list,
+                region_areas_list,
+                index,
+                method,
+                object_cutoff,
+                atlas_volume,
+                use_flat,
+            ),
+        )
+        threads.append(x)
+        ## This converts the segmentation to a point cloud
+    # Start threads
+    [t.start() for t in threads]
+    # Wait for threads to finish
+    [t.join() for t in threads]
+    # Flatten points_list
+
+    points_len = [
+        len(points) if None not in points else 0 for points in points_list
+        ]
+    centroids_len = [
+             len(centroids) if None not in centroids else 0 for centroids in centroids_list
+         ]
+    points_list = [points for points in points_list if None not in points]
+    centroids_list = [centroids for centroids in centroids_list if None not in centroids]
+    if len(points_list) == 0:
+        points = np.array([])
+    else:
+        points = np.concatenate(points_list)
+    if len(centroids_list) == 0:
+        centroids = np.array([])
+    else:
+        centroids = np.concatenate(centroids_list)
+
+
+    return (
+        np.array(points),
+        np.array(centroids),
+        region_areas_list,
+        points_len,
+        centroids_len,
+        segmentations,
+    )
+
+def load_segmentation(segmentation_path: str):
+    """Load a segmentation from a file."""
+    print(f"working on {segmentation_path}")
+    if segmentation_path.endswith(".dzip"):
+        print("Reconstructing dzi")
+        return reconstruct_dzi(segmentation_path)
+    else:
+        return cv2.imread(segmentation_path)
+
+def detect_pixel_id(segmentation: np.array):
+    """Remove the background from the segmentation and return the pixel id."""
+    segmentation_no_background = segmentation[~np.all(segmentation == 0, axis=2)]
+    pixel_id = segmentation_no_background[0]
+    print("detected pixel_id: ", pixel_id)
+    return pixel_id
+
+def get_region_areas(use_flat, atlas_labels, flat_file_atlas, seg_width, seg_height, slice_dict, atlas_volume, triangulation):
+    if use_flat:
+        region_areas = flat_to_dataframe(
+            atlas_labels, flat_file_atlas, (seg_width, seg_height)
+        )
+    else:
+        region_areas = flat_to_dataframe(
+            atlas_labels,
+            flat_file_atlas,
+            (seg_width, seg_height),
+            slice_dict["anchoring"],
+            atlas_volume,
+            triangulation
+        )
+    return region_areas
+
+def get_transformed_coordinates(non_linear, slice_dict, method, scaled_x, scaled_y, centroids, scaled_centroidsX, scaled_centroidsY, triangulation):
+    new_x, new_y, centroids_new_x, centroids_new_y = None, None, None, None
+    if non_linear and "markers" in slice_dict:
+        if method in ["per_pixel", "all"] and scaled_x is not None:
+            new_x, new_y = transform_vec(triangulation, scaled_x, scaled_y)
+        if method in ["per_object", "all"] and centroids is not None:
+            centroids_new_x, centroids_new_y = transform_vec(triangulation, scaled_centroidsX, scaled_centroidsY)
+    else:
+        if method in ["per_pixel", "all"]:
+            new_x, new_y = scaled_x, scaled_y
+        if method in ["per_object", "all"]:
+            centroids_new_x, centroids_new_y = scaled_centroidsX, scaled_centroidsY
+    return new_x, new_y, centroids_new_x, centroids_new_y
+
+def segmentation_to_atlas_space(
+    slice_dict,
+    segmentation_path,
+    atlas_labels,
+    flat_file_atlas=None,
+    pixel_id="auto",
+    non_linear=True,
+    points_list=None,
+    centroids_list=None,
+    region_areas_list=None,
+    index=None,
+    method="per_pixel",
+    object_cutoff=0,
+    atlas_volume=None,
+    use_flat=False,
+):
+    segmentation = load_segmentation(segmentation_path)
+    if pixel_id == "auto":
+        pixel_id = detect_pixel_id(segmentation)
+    seg_height, seg_width = segmentation.shape[:2]
+    reg_height, reg_width = slice_dict["height"], slice_dict["width"]
+    if non_linear and "markers" in slice_dict:
+        triangulation = triangulate(reg_width, reg_height, slice_dict["markers"])
+    else:
+        triangulation = None
+    region_areas = get_region_areas(use_flat, atlas_labels, flat_file_atlas, seg_width, seg_height, slice_dict, atlas_volume, triangulation)
+    y_scale, x_scale = transform_to_registration(seg_height, seg_width, reg_height, reg_width)
+    centroids, points = None, None
+    scaled_centroidsX, scaled_centroidsY, scaled_x, scaled_y = None, None, None, None 
+    if method in ["per_object", "all"]:
+        centroids, scaled_centroidsX, scaled_centroidsY = get_centroids(segmentation, pixel_id, y_scale, x_scale, object_cutoff)
+    if method in ["per_pixel", "all"]:
+        scaled_y, scaled_x = get_scaled_pixels(segmentation, pixel_id, y_scale, x_scale)
+
+    new_x, new_y, centroids_new_x, centroids_new_y = get_transformed_coordinates(non_linear, slice_dict, method, scaled_x, scaled_y, centroids, scaled_centroidsX, scaled_centroidsY, triangulation)
+    if method in ["per_pixel", "all"] and new_x is not None:
+        points = transform_to_atlas_space(slice_dict["anchoring"], new_y, new_x, reg_height, reg_width)
+    if method in ["per_object", "all"] and centroids_new_x is not None:
+        centroids = transform_to_atlas_space(slice_dict["anchoring"], centroids_new_y, centroids_new_x, reg_height, reg_width)
+    points_list[index] = np.array(points if points is not None else [])
+    centroids_list[index] = np.array(centroids if centroids is not None else [])
+    region_areas_list[index] = region_areas
+
+
+def get_centroids(segmentation, pixel_id, y_scale, x_scale, object_cutoff=0):
+    binary_seg = segmentation == pixel_id
+    binary_seg = np.all(binary_seg, axis=2)
+    centroids, area, coords = get_centroids_and_area(
+        binary_seg, pixel_cut_off=object_cutoff
+    )
+
+    print(f"using pixel id {pixel_id}")
+    print(f"Found {len(centroids)} objects in the segmentation")
+    if len(centroids) == 0:
+        return None, None, None
+    centroidsX = centroids[:, 1]
+    centroidsY = centroids[:, 0]
+    scaled_centroidsY, scaled_centroidsX = scale_positions(
+        centroidsY, centroidsX, y_scale, x_scale
+    )
+    return centroids, scaled_centroidsX, scaled_centroidsY
+
+
+def get_scaled_pixels(segmentation, pixel_id, y_scale, x_scale):
+    id_pixels = find_matching_pixels(segmentation, pixel_id)
+    if len(id_pixels[0]) == 0:
+        return None, None
+    # Scale the seg coordinates to reg/seg
+    scaled_y, scaled_x = scale_positions(id_pixels[0], id_pixels[1], y_scale, x_scale)
+    return scaled_y, scaled_x

PyNutil/counting_and_load.py

@@ -0,0 +1,241 @@
+import numpy as np
+import pandas as pd
+import struct
+import cv2
+from .generate_target_slice import generate_target_slice
+from .visualign_deformations import transform_vec
+
+# related to counting and load
+def label_points(points, label_volume, scale_factor=1):
+    """This function takes a list of points and assigns them to a region based on the region_volume.
+    These regions will just be the values in the region_volume at the points.
+    It returns a dictionary with the region as the key and the points as the value."""
+    # First convert the points to 3 columns
+    points = np.reshape(points, (-1, 3))
+    # Scale the points
+    points = points * scale_factor
+    # Round the points to the nearest whole number
+    points = np.round(points).astype(int)
+    x = points[:, 0]
+    y = points[:, 1]
+    z = points[:, 2]
+
+    # make sure the points are within the volume
+    x[x < 0] = 0
+    y[y < 0] = 0
+    z[z < 0] = 0
+    mask = (
+        (x > label_volume.shape[0] - 1)
+        | (y > label_volume.shape[1] - 1)
+        | (z > label_volume.shape[2] - 1)
+    )
+    x[mask] = 0
+    y[mask] = 0
+    z[mask] = 0
+
+    # Get the label value for each point
+    labels = label_volume[x, y, z]
+
+    return labels
+
+
+# related to counting_and_load
+def pixel_count_per_region(
+    labels_dict_points, labeled_dict_centroids, df_label_colours
+):
+    """Function for counting no. of pixels per region and writing to CSV based on
+    a dictionary with the region as the key and the points as the value."""
+    if labels_dict_points is not None and labeled_dict_centroids is not None:
+        counted_labels_points, label_counts_points = np.unique(
+            labels_dict_points, return_counts=True
+        )
+        counted_labels_centroids, label_counts_centroids = np.unique(
+            labeled_dict_centroids, return_counts=True
+        )
+        # Which regions have pixels, and how many pixels are there per region
+        counts_per_label = list(
+            zip(counted_labels_points, label_counts_points, label_counts_centroids)
+        )
+        # Create a list of unique regions and pixel counts per region
+        df_counts_per_label = pd.DataFrame(
+            counts_per_label, columns=["idx", "pixel_count", "object_count"]
+        )
+    elif labels_dict_points is None and labeled_dict_centroids is not None:
+        counted_labels_centroids, label_counts_centroids = np.unique(
+            labeled_dict_centroids, return_counts=True
+        )
+        # Which regions have pixels, and how many pixels are there per region
+        counts_per_label = list(zip(counted_labels_centroids, label_counts_centroids))
+        # Create a list of unique regions and pixel counts per region
+        df_counts_per_label = pd.DataFrame(
+            counts_per_label, columns=["idx", "object_count"]
+        )
+    elif labels_dict_points is not None and labeled_dict_centroids is None:
+        counted_labels_points, label_counts_points = np.unique(
+            labels_dict_points, return_counts=True
+        )
+        # Which regions have pixels, and how many pixels are there per region
+        counts_per_label = list(zip(counted_labels_points, label_counts_points))
+        # Create a list of unique regions and pixel counts per region
+        df_counts_per_label = pd.DataFrame(
+            counts_per_label, columns=["idx", "pixel_count"]
+        )
+    # Create a pandas df with regions and pixel counts
+
+    # df_label_colours = pd.read_csv(label_colours, sep=",")
+    # Find colours corresponding to each region ID and add to the pandas dataframe
+
+    # Look up name, r, g, b in df_allen_colours in df_counts_per_label based on "idx"
+    # Sharon, remove this here
+    new_rows = []
+    for index, row in df_counts_per_label.iterrows():
+        mask = df_label_colours["idx"] == row["idx"]
+        current_region_row = df_label_colours[mask]
+        current_region_name = current_region_row["name"].values
+        current_region_red = current_region_row["r"].values
+        current_region_green = current_region_row["g"].values
+        current_region_blue = current_region_row["b"].values
+
+        row["name"] = current_region_name[0]
+        row["r"] = int(current_region_red[0])
+        row["g"] = int(current_region_green[0])
+        row["b"] = int(current_region_blue[0])
+
+        new_rows.append(row)
+
+    df_counts_per_label_name = pd.DataFrame(
+        new_rows, columns=["idx", "name", "pixel_count", "object_count", "r", "g", "b"]
+    )
+    # Task for Sharon:
+    # If you can get the areas per region from the flat file here
+    # you can then use those areas to calculate the load per region here
+    # and add to dataframe
+    # see messing around pyflat.py
+
+    return df_counts_per_label_name
+
+
+"""Read flat file and write into an np array"""
+"""Read flat file, write into an np array, assign label file values, return array"""
+
+
+
+def read_flat_file(file):
+    with open(file, "rb") as f:
+        b, w, h = struct.unpack(">BII", f.read(9))
+        data = struct.unpack(">" + ("xBH"[b] * (w * h)), f.read(b * w * h))
+    image_data = np.array(data)
+    image = np.zeros((h, w))
+    for x in range(w):
+        for y in range(h):
+            image[y, x] = image_data[x + y * w]
+    return image
+
+
+def read_seg_file(file):
+    with open(file, "rb") as f:
+
+        def byte():
+            return f.read(1)[0]
+
+        def code():
+            c = byte()
+            if c < 0:
+                raise "!"
+            return c if c < 128 else (c & 127) | (code() << 7)
+
+        if "SegRLEv1" != f.read(8).decode():
+            raise "Header mismatch"
+        atlas = f.read(code()).decode()
+        print(f"Target atlas: {atlas}")
+        codes = [code() for x in range(code())]
+        w = code()
+        h = code()
+        data = []
+        while len(data) < w * h:
+            data += [codes[byte() if len(codes) <= 256 else code()]] * (code() + 1)
+    image_data = np.array(data)
+    image = np.reshape(image_data, (h, w))
+    return image
+
+
+def rescale_image(image, rescaleXY):
+    w, h = rescaleXY
+    return cv2.resize(image, (h, w), interpolation=cv2.INTER_NEAREST)
+
+def assign_labels_to_image(image, labelfile):
+    w, h = image.shape
+    allen_id_image = np.zeros((h, w))  # create an empty image array
+    coordsy, coordsx = np.meshgrid(list(range(w)), list(range(h)))
+
+    values = image[coordsy, coordsx]
+    lbidx = labelfile["idx"].values
+
+    allen_id_image = lbidx[values.astype(int)]
+    return allen_id_image
+
+
+def count_pixels_per_label(image, scale_factor=False):
+    unique_ids, counts = np.unique(image, return_counts=True)
+    if scale_factor:
+        counts = counts * scale_factor
+    area_per_label = list(zip(unique_ids, counts))
+    df_area_per_label = pd.DataFrame(area_per_label, columns=["idx", "region_area"])
+    return df_area_per_label
+
+
+def warp_image(image, triangulation, rescaleXY):
+    if rescaleXY is not None:
+        w,h = rescaleXY
+    else:
+        h, w = image.shape
+    reg_h, reg_w = image.shape
+    oldX, oldY = np.meshgrid(np.arange(reg_w), np.arange(reg_h))
+    oldX = oldX.flatten()
+    oldY = oldY.flatten()
+    h_scale = h / reg_h
+    w_scale = w / reg_w
+    oldX = oldX * w_scale
+    oldY = oldY * h_scale
+    newX, newY = transform_vec(triangulation, oldX, oldY)
+    newX = newX / w_scale
+    newY = newY / h_scale
+    newX = newX.reshape(reg_h, reg_w)
+    newY = newY.reshape(reg_h, reg_w)
+    newX = newX.astype(int)
+    newY = newY.astype(int)
+    newX[newX >= reg_w] = reg_w - 1
+    newY[newY >= reg_h] = reg_h - 1
+    newX[newX < 0] = 0
+    newY[newY < 0] = 0
+    new_image = image[newY, newX]
+    return new_image
+
+def flat_to_dataframe(
+    labelfile, file=None, rescaleXY=None, image_vector=None, volume=None, triangulation=None
+):
+    if (image_vector is not None) and (volume is not None):
+        image = generate_target_slice(image_vector, volume)
+        image = np.float64(image)
+        if triangulation is not None:
+            image = warp_image(image, triangulation, rescaleXY)
+    elif file.endswith(".flat"):
+        image = read_flat_file(file)
+    elif file.endswith(".seg"):
+        image = read_seg_file(file)
+    print("datatype", image.dtype)
+    print("image shape open", image.shape)
+
+    if rescaleXY:
+        image_shapeY, image_shapeX = image.shape[0], image.shape[1]
+        image_pixels = image_shapeY * image_shapeX
+        seg_pixels = rescaleXY[0] * rescaleXY[1]
+        scale_factor = seg_pixels / image_pixels
+    else:
+        scale_factor = False
+    if (image_vector is None) or (volume is None):
+        allen_id_image = assign_labels_to_image(image, labelfile)
+    else:
+        allen_id_image = image
+    df_area_per_label = count_pixels_per_label(allen_id_image, scale_factor)
+    return df_area_per_label

PyNutil/generate_target_slice.py

@@ -0,0 +1,35 @@
+import numpy as np
+import math
+
+def generate_target_slice(ouv, atlas):
+    width = None
+    height = None
+    ox, oy, oz, ux, uy, uz, vx, vy, vz = ouv
+    width = np.floor(math.hypot(ux,uy,uz)).astype(int) + 1
+    height = np.floor(math.hypot(vx,vy,vz)).astype(int) + 1
+    data = np.zeros((width, height), dtype=np.uint32).flatten()
+    xdim, ydim, zdim = atlas.shape
+    y_values = np.arange(height)
+    x_values = np.arange(width)
+    hx = ox + vx * (y_values / height)
+    hy = oy + vy * (y_values / height)
+    hz = oz + vz * (y_values / height)
+    wx = ux * (x_values / width)
+    wy = uy * (x_values / width)
+    wz = uz * (x_values / width)
+    lx = np.floor(hx[:, None] + wx).astype(int) 
+    ly = np.floor(hy[:, None] + wy).astype(int) 
+    lz = np.floor(hz[:, None] + wz).astype(int) 
+    valid_indices = (0 <= lx) & (lx < xdim) & (0 <= ly) & (ly < ydim) & (0 <= lz) & (lz < zdim)
+    valid_indices = valid_indices.flatten()
+    lxf = lx.flatten()
+    lyf = ly.flatten()
+    lzf = lz.flatten()
+    valid_lx = lxf[valid_indices]
+    valid_ly = lyf[valid_indices]
+    valid_lz = lzf[valid_indices]
+    atlas_slice = atlas[valid_lx,valid_ly,valid_lz]
+    data[valid_indices] = atlas_slice
+    data_im = data.reshape((height, width))
+    return data_im
+

PyNutil/load_workflow.py

@@ -0,0 +1,67 @@
+"""Create workflow for calculating load based on atlas maps and segmentations"""
+
+import pandas as pd
+import cv2
+
+# from read_and_write import flat_to_array, label_to_array
+from counting_and_load import flat_to_dataframe
+
+base = r"../test_data/tTA_2877_NOP_s037_atlasmap/2877_NOP_tTA_lacZ_Xgal_s037_nl.flat"
+label = r"../annotation_volumes\allen2017_colours.csv"
+##optional
+seg = r"../test_data/tTA_2877_NOP_s037_seg/2877_NOP_tTA_lacZ_Xgal_resize_Simple_Seg_s037.png"
+segim = cv2.imread(seg)
+# the indexing [:2] means the first two values and [::-1] means reverse the list
+segXY = segim.shape[:2][::-1]
+# image_arr = flat_to_array(base, label)
+
+# plt.imshow(flat_to_array(base, label))
+
+df_area_per_label = flat_to_dataframe(base, label, segXY)
+
+"""count pixels in np array for unique idx, return pd df"""
+# unique_ids, counts = np.unique(allen_id_image, return_counts=True)
+
+# area_per_label = list(zip(unique_ids, counts))
+# create a list of unique regions and pixel counts per region
+
+# df_area_per_label = pd.DataFrame(area_per_label, columns=["idx", "area_count"])
+# create a pandas df with regions and pixel counts
+
+
+"""add region name and colours corresponding to each idx into dataframe.
+This could be a separate function"""
+
+df_label_colours = pd.read_csv(label, sep=",")
+# find colours corresponding to each region ID and add to the pandas dataframe
+
+# look up name, r, g, b in df_allen_colours in df_area_per_label based on "idx"
+new_rows = []
+for index, row in df_area_per_label.iterrows():
+    mask = df_label_colours["idx"] == row["idx"]
+    current_region_row = df_label_colours[mask]
+    current_region_name = current_region_row["name"].values
+    current_region_red = current_region_row["r"].values
+    current_region_green = current_region_row["g"].values
+    current_region_blue = current_region_row["b"].values
+
+    row["name"] = current_region_name[0]
+    row["r"] = current_region_red[0]
+    row["g"] = current_region_green[0]
+    row["b"] = current_region_blue[0]
+
+    new_rows.append(row)
+
+df_area_per_label_name = pd.DataFrame(new_rows)
+
+print(df_area_per_label_name)
+df_area_per_label_name.to_csv(
+    "../outputs/NOP_s037_regionareas.csv", sep=";", na_rep="", index=False
+)
+
+
+# Count area per unique label in one flat file - done.
+# Scale up to size of corresponding segmentation/ or size of reference atlas if points are already scaled?
+# divide "segmentation value per idx per slice" by "area per idx per slice"
+# also do for whole brain - need to loop through and match up section with corresponding atlasmap
+# output reports per brain and per slice