nettracer3d 0.2.7__tar.gz → 0.2.9__tar.gz

{nettracer3d-0.2.7/src/nettracer3d.egg-info → nettracer3d-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.2.7
+Version: 0.2.9
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <boom2449@gmail.com>
 Project-URL: User_Manual, https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link

{nettracer3d-0.2.7 → nettracer3d-0.2.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "0.2.7"
+version = "0.2.9"
 authors = [
   { name="Liam McLaughlin", email="boom2449@gmail.com" },
 ]

{nettracer3d-0.2.7 → nettracer3d-0.2.9}/src/nettracer3d/community_extractor.py

@@ -2,7 +2,7 @@ import pandas as pd
 import networkx as nx
 import tifffile
 import numpy as np
-from typing import List, Dict, Tuple
+from typing import List, Dict, Tuple, Union, Any
 from collections import defaultdict, Counter
 from networkx.algorithms import community
 from scipy import ndimage
@@ -648,7 +648,69 @@ def find_hub_nodes(G: nx.Graph, proportion: float = 0.1) -> List:
     
     return hub_nodes
 
+def get_color_name_mapping():
+    """Return a dictionary of common colors and their RGB values."""
+    return {
+        'red': (255, 0, 0),
+        'green': (0, 255, 0),
+        'blue': (0, 0, 255),
+        'yellow': (255, 255, 0),
+        'cyan': (0, 255, 255),
+        'magenta': (255, 0, 255),
+        'purple': (128, 0, 128),
+        'orange': (255, 165, 0),
+        'brown': (165, 42, 42),
+        'pink': (255, 192, 203),
+        'navy': (0, 0, 128),
+        'teal': (0, 128, 128),
+        'olive': (128, 128, 0),
+        'maroon': (128, 0, 0),
+        'lime': (50, 205, 50),
+        'indigo': (75, 0, 130),
+        'violet': (238, 130, 238),
+        'coral': (255, 127, 80),
+        'turquoise': (64, 224, 208),
+        'gold': (255, 215, 0)
+    }
+
+def rgb_to_color_name(rgb: Tuple[int, int, int]) -> str:
+    """
+    Convert an RGB tuple to its nearest color name.
+    
+    Args:
+        rgb: Tuple of (r, g, b) values
+        
+    Returns:
+        str: Name of the closest matching color
+    """
+    color_map = get_color_name_mapping()
+    
+    # Convert input RGB to numpy array
+    rgb_array = np.array(rgb)
+    
+    # Calculate Euclidean distance to all known colors
+    min_distance = float('inf')
+    closest_color = None
+    
+    for color_name, color_rgb in color_map.items():
+        distance = np.sqrt(np.sum((rgb_array - np.array(color_rgb)) ** 2))
+        if distance < min_distance:
+            min_distance = distance
+            closest_color = color_name
+            
+    return closest_color
 
+def convert_node_colors_to_names(node_to_color: Dict[int, Tuple[int, int, int]]) -> Dict[int, str]:
+    """
+    Convert a dictionary of node-to-RGB mappings to node-to-color-name mappings.
+    
+    Args:
+        node_to_color: Dictionary mapping node IDs to RGB tuples
+        
+    Returns:
+        Dictionary mapping node IDs to color names
+    """
+    return {node: rgb_to_color_name(color) for node, color in node_to_color.items()}
 
 def generate_distinct_colors(n_colors: int) -> List[Tuple[int, int, int]]:
     """
@@ -721,33 +783,55 @@ def assign_community_colors(community_dict: Dict[int, int], labeled_array: np.nd
             mask = labeled_array == label
             for i in range(3):  # RGB channels
                 rgb_array[mask, i] = node_to_color[label][i]
+
+    node_to_color_names = convert_node_colors_to_names(community_to_color)
+
     
-    return rgb_array
+    return rgb_array, node_to_color_names
 
-def assign_community_grays(community_dict: Dict[int, int], labeled_array: np.ndarray) -> np.ndarray:
+def assign_community_grays(community_dict: Dict[int, Union[int, str, Any]], labeled_array: np.ndarray) -> np.ndarray:
     """
-    Assign distinct grayscale values to communities.
+    Assign grayscale values to communities. For numeric communities, uses the community
+    number directly. For string/other communities, assigns sequential values.
     
     Args:
-        community_dict: Dictionary mapping node IDs to community numbers
+        community_dict: Dictionary mapping node IDs to community identifiers (numbers or strings)
         labeled_array: 3D numpy array with labels corresponding to node IDs
     
     Returns:
-        grayscale numpy array
+        tuple: (grayscale numpy array, mapping of node IDs to assigned values)
     """
-    # Get unique communities
-    communities = set(community_dict.values())
-    n_communities = len(communities)
+    # Determine if we're dealing with numeric or string communities
+    sample_value = next(iter(community_dict.values()))
+    is_numeric = isinstance(sample_value, (int, float))
     
-    # Generate evenly spaced grayscale values (excluding pure black for background)
-    gray_values = np.linspace(1, 255, n_communities, dtype=np.uint8)
+    if is_numeric:
+        # For numeric communities, use values directly
+        node_to_gray = community_dict
+        max_val = max(community_dict.values())
+    else:
+        # For string/other communities, assign sequential values
+        unique_communities = sorted(set(community_dict.values()))
+        community_to_value = {comm: i+1 for i, comm in enumerate(unique_communities)}
+        node_to_gray = {node: community_to_value[comm] for node, comm in community_dict.items()}
+        max_val = len(unique_communities)
     
-    # Create direct mapping from node ID to grayscale value
-    node_to_gray = {node: gray_values[list(communities).index(comm)] 
-                   for node, comm in community_dict.items()}
+    # Choose appropriate dtype based on maximum value
+    if max_val <= 255:
+        dtype = np.uint8
+    elif max_val <= 65535:
+        dtype = np.uint16
+    else:
+        dtype = np.uint32
     
     # Create output array
-    gray_array = np.zeros_like(labeled_array, dtype=np.uint8)
+    gray_array = np.zeros_like(labeled_array, dtype=dtype)
+    
+    # Create mapping of unique communities to their grayscale values
+    if is_numeric:
+        community_to_gray = {comm: comm for comm in set(community_dict.values())}
+    else:
+        community_to_gray = {comm: i+1 for i, comm in enumerate(sorted(set(community_dict.values())))}
     
     # Use numpy's vectorized operations for faster assignment
     unique_labels = np.unique(labeled_array)
@@ -755,7 +839,7 @@ def assign_community_grays(community_dict: Dict[int, int], labeled_array: np.nda
         if label in node_to_gray:
             gray_array[labeled_array == label] = node_to_gray[label]
     
-    return gray_array
+    return gray_array, community_to_gray
 
 
 if __name__ == "__main__":

{nettracer3d-0.2.7 → nettracer3d-0.2.9}/src/nettracer3d/morphology.py

@@ -270,51 +270,56 @@ def calculate_voxel_volumes(array, xy_scale=1, z_scale=1):
     return volumes
 
 
-def search_neighbor_ids(nodes, targets, id_dict, neighborhood_dict, totals, search, xy_scale, z_scale):
+def search_neighbor_ids(nodes, targets, id_dict, neighborhood_dict, totals, search, xy_scale, z_scale, root):
 
-    
+    if 0 in targets:
+        targets.remove(0)
     targets = np.isin(nodes, targets)
     targets = nettracer.binarize(targets)
     
     dilate_xy, dilate_z = nettracer.dilation_length_to_pixels(xy_scale, z_scale, search, search)
-    print(f"Dilation parameters - xy: {dilate_xy}, z: {dilate_z}")
     
-    targets = nettracer.dilate_3D_recursive(targets, dilate_xy, dilate_xy, dilate_z)
-    targets = targets != 0
-    print(f"After dilation - targets shape: {targets.shape}, sum: {np.sum(targets)}")
+    dilated = nettracer.dilate_3D_recursive(targets, dilate_xy, dilate_xy, dilate_z)
+    dilated = dilated - targets #technically we dont need the cores
+    search_vol = np.count_nonzero(dilated) * xy_scale * xy_scale * z_scale #need this for density
+    targets = dilated != 0
+    del dilated
+
     
     targets = targets * nodes
-    print(f"After multiplication with nodes - unique values in targets: {np.unique(targets)}")
     
     unique, counts = np.unique(targets, return_counts=True)
     count_dict = dict(zip(unique, counts))
-    print(f"Initial count_dict: {count_dict}")
+    print(count_dict)
     
     del count_dict[0]
-    print(f"count_dict after removing zeros: {count_dict}")
     
     unique, counts = np.unique(nodes, return_counts=True)
     total_dict = dict(zip(unique, counts))
-    print(f"Initial total_dict: {total_dict}")
-    
+    print(total_dict)
+
     del total_dict[0]
-    print(f"total_dict after removing zeros: {total_dict}")
     
-    print(f"id_dict keys: {list(id_dict.keys())}")
-    print(f"Initial neighborhood_dict: {neighborhood_dict}")
-    print(f"Initial totals: {totals}")
     
     for label in total_dict:
         if label in id_dict:
             if label in count_dict:
                 neighborhood_dict[id_dict[label]] += count_dict[label]
-                print(f"Updated neighborhood_dict[{id_dict[label]}] with count {count_dict[label]}")
             totals[id_dict[label]] += total_dict[label]
-            print(f"Updated totals[{id_dict[label]}] with total {total_dict[label]}")
+
+
+    try:
+        del neighborhood_dict[root]  #no good way to get this
+        del totals[root] #no good way to get this
+    except:
+        pass
     
-    print(f"Final neighborhood_dict: {neighborhood_dict}")
-    print(f"Final totals: {totals}")
-    return neighborhood_dict, totals
+    volume = nodes.shape[0] * nodes.shape[1] * nodes.shape[2] * xy_scale * xy_scale * z_scale
+    densities = {}
+    for nodeid, amount in totals.items():
+        densities[nodeid] = (neighborhood_dict[nodeid]/search_vol)/(amount/volume)
+
+    return neighborhood_dict, totals, densities
 
 
 

{nettracer3d-0.2.7 → nettracer3d-0.2.9}/src/nettracer3d/nettracer.py

@@ -322,15 +322,25 @@ def create_and_save_dataframe(pairwise_connections, excel_filename = None):
         df = pd.concat([df, temp_df], axis=1)
 
     if excel_filename is not None:
-
-        try:
+        # Remove file extension if present to use as base path
+        base_path = excel_filename.rsplit('.', 1)[0]
         
-            # Save the DataFrame to an Excel file
-            df.to_excel(excel_filename, index=False)
-            print(f"Network file saved to {excel_filename}")
-
+        # First try to save as CSV
+        try:
+            csv_path = f"{base_path}.csv"
+            df.to_csv(csv_path, index=False)
+            print(f"Network file saved to {csv_path}")
+            return
         except Exception as e:
-            print(f"Unable to write network file to disk... please make sure that {excel_filename} is being saved to a valid directory and try again")
+            print(f"Could not save as CSV: {str(e)}")
+            
+            # If CSV fails, try to save as Excel
+            try:
+                xlsx_path = f"{base_path}.xlsx"
+                df.to_excel(xlsx_path, index=False)
+                print(f"Network file saved to {xlsx_path}")
+            except Exception as e:
+                print(f"Unable to write network file to disk... please make sure that {base_path}.xlsx is being saved to a valid directory and try again")
 
     else:
         return df
@@ -1383,7 +1393,7 @@ def binarize(arrayimage, directory = None):
 
     return arrayimage
 
-def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast_dil = False):
+def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast_dil = False, recursive = False):
     """
     Can be used to dilate a binary image in 3D. Dilated output will be saved to the active directory if none is specified. Note that dilation is done with single-instance kernels and not iterations, and therefore
     objects will lose their shape somewhat and become cube-ish if the 'amount' param is ever significantly larger than the objects in quesiton.
@@ -1408,13 +1418,15 @@ def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast
     if len(np.unique(arrayimage)) > 2: #binarize
         arrayimage = binarize(arrayimage)
 
-    if not fast_dil:
+    if not fast_dil and not recursive:
         arrayimage = (dilate_3D(arrayimage, dilate_xy, dilate_xy, dilate_z)) * 255
         if np.max(arrayimage) == 1:
             arrayimage = arrayimage * 255
-
-    else:
+    elif not recursive:
         arrayimage = (dilate_3D_old(arrayimage, dilate_xy, dilate_xy, dilate_z)) * 255
+    else:
+        arrayimage = (dilate_3D_recursive(arrayimage, dilate_xy, dilate_xy, dilate_z)) * 255
+
 
 
     if type(image) == str:
@@ -1935,6 +1947,9 @@ def encapsulate(parent_dir = None, name = None):
     
     return new_folder_path
 
+
+
+
 #THE 3D NETWORK CLASS
 
 class Network_3D:
@@ -2420,7 +2435,7 @@ class Network_3D:
 
 
         if filename is None:
-            filename = "drawn_network.tif"
+            filename = "overlay_1.tif"
         elif not filename.endswith(('.tif', '.tiff')):
             filename += '.tif'
 
@@ -2436,7 +2451,7 @@ class Network_3D:
     def save_id_overlay(self, directory = None, filename = None):
 
         if filename is None:
-            filename = "labelled_node_indices.tif"
+            filename = "overlay_2.tif"
         if not filename.endswith(('.tif', '.tiff')):
             filename += '.tif'
 
@@ -2457,9 +2472,7 @@ class Network_3D:
         :param directory: (Optional - Val = None; String). The path to an intended directory to save the properties to.
         """
 
-
-        if directory is None:
-            directory = encapsulate(parent_dir = parent_dir, name = name)
+        directory = encapsulate(parent_dir = parent_dir, name = name)
 
         try:
             self.save_nodes(directory)
@@ -2720,7 +2733,7 @@ class Network_3D:
         items = directory_info(directory)
 
         for item in items:
-            if item == 'node_communities.xlsx':
+            if item == 'node_communities.xlsx' or item == 'node_communities.csv':
                 if directory is not None:
                     self._communities = network_analysis.read_excel_to_singval_dict(f'{directory}/{item}')
                     print("Succesfully loaded communities")
@@ -2772,7 +2785,7 @@ class Network_3D:
         items = directory_info(directory)
 
         for item in items:
-            if item == 'drawn_network.tif':
+            if item == 'overlay_1.tif':
                 if directory is not None:
                     self._network_overlay = tifffile.imread(f'{directory}/{item}')
                     print("Succesfully loaded network overlay")
@@ -2797,7 +2810,7 @@ class Network_3D:
         items = directory_info(directory)
 
         for item in items:
-            if item == 'labelled_node_indices.tif':
+            if item == 'overlay_2.tif':
                 if directory is not None:
                     self._id_overlay = tifffile.imread(f'{directory}/{item}')
                     print("Succesfully loaded id overlay")
@@ -2811,7 +2824,7 @@ class Network_3D:
         #print("Could not find id overlay. They must be in the specified directory and named 'labelled_node_indices.tif'")
 
 
-    def assemble(self, directory = None, node_path = None, edge_path = None, search_region_path = None, network_path = None, node_centroids_path = None, node_identities_path = None, edge_centroids_path = None, scaling_path = None, net_overlay_path = None, id_overlay_path = None):
+    def assemble(self, directory = None, node_path = None, edge_path = None, search_region_path = None, network_path = None, node_centroids_path = None, node_identities_path = None, edge_centroids_path = None, scaling_path = None, net_overlay_path = None, id_overlay_path = None, community_path = None ):
         """
         Can be called on a Network_3D object to load all properties simultaneously from a specified directory. It will look for files with the names specified in the property loading methods, in the active directory if none is specified.
         Alternatively, for each property a filepath to any file may be passed to look there to load. This method is intended to be used together with the dump method to easily save and load the Network_3D objects once they had been calculated. 
@@ -2835,6 +2848,7 @@ class Network_3D:
         self.load_node_identities(directory, node_identities_path)
         self.load_edge_centroids(directory, edge_centroids_path)
         self.load_scaling(directory, scaling_path)
+        self.load_communities(directory, community_path)
         self.load_network_overlay(directory, net_overlay_path)
         self.load_id_overlay(directory, id_overlay_path)
 
@@ -3127,8 +3141,7 @@ class Network_3D:
         """
 
 
-        if directory is None:
-            directory = encapsulate()
+        directory = encapsulate()
 
         self._xy_scale = xy_scale
         self._z_scale = z_scale
@@ -3906,25 +3919,37 @@ class Network_3D:
         return hubs, hub_img
 
 
-    def extract_communities(self, color_code = True, down_factor = None):
+    def extract_communities(self, color_code = True, down_factor = None, identities = False):
 
         if down_factor is not None:
             original_shape = self._nodes.shape
             temp = downsample(self._nodes, down_factor)
             if color_code:
-                image = community_extractor.assign_community_colors(self.communities, temp)
+                if not identities:
+                    image, output = community_extractor.assign_community_colors(self.communities, temp)
+                else:
+                    image, output = community_extractor.assign_community_colors(self.node_identities, temp)
             else:
-                image = community_extractor.assign_community_grays(self.communities, temp)
+                if not identities:
+                    image, output = community_extractor.assign_community_grays(self.communities, temp)
+                else:
+                    image, output = community_extractor.assign_community_grays(self.node_identities, temp)
             image = upsample_with_padding(image, down_factor, original_shape)
         else:
 
             if color_code:
-                image = community_extractor.assign_community_colors(self.communities, self._nodes)
+                if not identities:
+                    image, output = community_extractor.assign_community_colors(self.communities, self._nodes)
+                else:
+                    image, output = community_extractor.assign_community_colors(self.node_identities, self._nodes)
             else:
-                image = community_extractor.assign_community_grays(self.communities, self._nodes)
+                if not identities:
+                    image, output = community_extractor.assign_community_grays(self.communities, self._nodes)
+                else:
+                    image, output = community_extractor.assign_community_grays(self.node_identities, self._nodes)
 
 
-        return image
+        return image, output
         
 
 
@@ -4072,6 +4097,14 @@ class Network_3D:
         except:
             stats['degree_assortativity'] = "Failed to compute"
 
+        try:
+            nodes = np.unique(self._nodes)
+            if nodes[0] == 0:
+                nodes = np.delete(nodes, 0)
+            stats['Unconnected nodes (left out from node image)'] = (len(nodes) - len(G.nodes()))
+        except:
+            stats['Unconnected nodes (left out from node image)'] = "Failed to compute"
+
         
         return stats
 
@@ -4114,9 +4147,9 @@ class Network_3D:
 
 
         elif mode == 1: #Search neighborhoods morphologically, obtain densities
-            neighborhood_dict, total_dict = morphology.search_neighbor_ids(self._nodes, targets, node_identities, neighborhood_dict, total_dict, search, self._xy_scale, self._z_scale)
-            title1 = f'Volumetric Neighborhood Distribution of Nodes in image from Nodes: {root}'
-            title2 = f'Density Distribution of Nodes in image from Nodes {root} as a proportion of total node volume of that ID'
+            neighborhood_dict, total_dict, densities = morphology.search_neighbor_ids(self._nodes, targets, node_identities, neighborhood_dict, total_dict, search, self._xy_scale, self._z_scale, root)
+            title1 = f'Volumetric Neighborhood Distribution of Nodes in image that are {search} from nodes: {root}'
+            title2 = f'Density Distribution of Nodes in image that are {search} from Nodes {root} as a proportion of total node volume of that ID'
 
 
         for identity in neighborhood_dict:
@@ -4126,11 +4159,13 @@ class Network_3D:
 
         network_analysis.create_bar_graph(proportion_dict, title2, "Node Identity", "Proportion", directory=directory)
 
+        try:
+            network_analysis.create_bar_graph(densities, f'Clustering Factor of Node Identities with {search} from nodes {root}', "Node Identity", "Density Search/Density Total", directory=directory)
+        except:
+            densities = None
 
 
-
-
-        return neighborhood_dict, proportion_dict, title1, title2
+        return neighborhood_dict, proportion_dict, title1, title2, densities
 
 
 

{nettracer3d-0.2.7 → nettracer3d-0.2.9}/src/nettracer3d/nettracer_gui.py

@@ -555,6 +555,8 @@ class ImageViewerWindow(QMainWindow):
                     if len(self.clicked_values['nodes']) > 1 or len(self.clicked_values['edges']) > 1:
                         combine_obj = highlight_menu.addAction("Combine Object Labels")
                         combine_obj.triggered.connect(self.handle_combine)
+                    split_obj = highlight_menu.addAction("Split Non-Touching Labels")
+                    split_obj.triggered.connect(self.handle_seperate)
                     delete_obj = highlight_menu.addAction("Delete Selection")
                     delete_obj.triggered.connect(self.handle_delete)
                     if len(self.clicked_values['nodes']) > 1:
@@ -991,6 +993,58 @@ class ImageViewerWindow(QMainWindow):
         except Exception as e:
             print(f"Error: {e}")
 
+    def handle_info(self, sort = 'node'):
+
+        try:
+
+            info_dict = {}
+
+            if sort == 'node':
+
+                label = self.clicked_values['nodes'][-1]
+
+                info_dict['Label'] = label
+
+                info_dict['Object Class'] = 'Node'
+
+                if my_network.node_identities is not None:
+                    info_dict['ID'] = my_network.node_identities[label]
+
+                if my_network.network is not None:
+                    info_dict['Degree'] = my_network.network.degree(label)
+
+                if my_network.communities is not None:
+                    info_dict['Community'] = my_network.communities[label]
+
+                if my_network.node_centroids is not None:
+                    info_dict['Centroid'] = my_network.node_centroids[label]
+
+                if self.volume_dict[0] is not None:
+                    info_dict['Volume'] = self.volume_dict[0][label]
+
+
+            elif sort == 'edge':
+
+                label = self.clicked_values['edges'][-1]
+
+                info_dict['Label'] = label
+
+                info_dict['Object Class'] = 'Edge'
+
+                if my_network.edge_centroids is not None:
+                    info_dict['Centroid'] = my_network.edge_centroids[label]
+
+                if self.volume_dict[1] is not None:
+                    info_dict['Volume'] = self.volume_dict[1][label]
+
+            self.format_for_upperright_table(info_dict, title = f'Info on Object')
+
+        except:
+            pass
+
+
+
+
     def handle_combine(self):
 
         try:
@@ -1040,12 +1094,73 @@ class ImageViewerWindow(QMainWindow):
                     for column in range(model.columnCount(None)):
                         self.network_table.resizeColumnToContents(column)
 
+                self.highlight_overlay = None
+                self.update_display()
+
+                self.show_centroid_dialog()
+
             except Exception as e:
                 print(f"Error, could not update network: {e}")
 
+
         except Exception as e:
             print(f"An error has occured: {e}")
 
+    def handle_seperate(self):
+
+        try:
+
+            if len(self.clicked_values['nodes']) > 0:
+                self.create_highlight_overlay(node_indices = self.clicked_values['nodes'])
+                max_val = np.max(my_network.nodes)
+                self.highlight_overlay, num = n3d.label_objects(self.highlight_overlay)
+
+                node_bools = self.highlight_overlay != 0
+                new_max = num + max_val
+                self.highlight_overlay = self.highlight_overlay + max_val
+                self.highlight_overlay = self.highlight_overlay * node_bools
+                if new_max < 256:
+                    dtype = np.uint8
+                elif new_max < 65536:
+                    dtype = np.uint16
+                else:
+                    dtype = np.uint32
+
+                self.highlight_overlay = self.highlight_overlay.astype(dtype)
+                my_network.nodes = my_network.nodes + self.highlight_overlay
+                self.load_channel(0, my_network.nodes, True)
+
+            if len(self.clicked_values['edges']) > 0:
+                self.create_highlight_overlay(edge_indices = self.clicked_values['edges'])
+                max_val = np.max(my_network.edges)
+                self.highlight_overlay, num = n3d.label_objects(self.highlight_overlay)
+                node_bools = self.highlight_overlay != 0
+                new_max = num + max_val
+
+                self.highlight_overlay = self.highlight_overlay + max_val
+                self.highlight_overlay = self.highlight_overlay * node_bools
+                if new_max < 256:
+                    dtype = np.uint8
+                elif new_max < 65536:
+                    dtype = np.uint16
+                else:
+                    dtype = np.uint32
+
+                self.highlight_overlay = self.highlight_overlay.astype(dtype)
+                my_network.edges = my_network.edges + self.highlight_overlay
+                self.load_channel(1, my_network.edges, True)
+            self.highlight_overlay = None
+            self.update_display()
+            print("Network is not updated automatically, please recompute if necesarry. Identities are not automatically updated.")
+            self.show_centroid_dialog()
+
+        except Exception as e:
+            print(f"Error seperating: {e}")
+
+
+
+
+
     def handle_delete(self):
 
         try:
@@ -1399,6 +1514,7 @@ class ImageViewerWindow(QMainWindow):
                         # Try to highlight the last selected value in tables
                         if self.clicked_values['edges']:
                             self.highlight_value_in_tables(self.clicked_values['edges'][-1])
+
             
             elif not self.selecting and self.selection_start:  # If we had a click but never started selection
                 # Handle as a normal click
@@ -1564,6 +1680,7 @@ class ImageViewerWindow(QMainWindow):
                             self.clicked_values = {'nodes': [clicked_value], 'edges': []}
                         # Get latest value (or the last remaining one if we just removed an item)
                         latest_value = self.clicked_values['nodes'][-1] if self.clicked_values['nodes'] else None
+                        self.handle_info('node')
                     elif self.active_channel == 1:
                         if ctrl_pressed:
                             if clicked_value in self.clicked_values['edges']:
@@ -1577,6 +1694,8 @@ class ImageViewerWindow(QMainWindow):
                             self.clicked_values = {'nodes': [], 'edges': [clicked_value]}
                         # Get latest value (or the last remaining one if we just removed an item)
                         latest_value = self.clicked_values['edges'][-1] if self.clicked_values['edges'] else None
+                        self.handle_info('edge')
+
                     
                     # Try to find and highlight the latest value in the current table
                     try:
@@ -1689,7 +1808,9 @@ class ImageViewerWindow(QMainWindow):
         mother_action = overlay_menu.addAction("Get Mother Nodes")
         mother_action.triggered.connect(self.show_mother_dialog)
         community_code_action = overlay_menu.addAction("Code Communities")
-        community_code_action.triggered.connect(self.show_code_dialog)
+        community_code_action.triggered.connect(lambda: self.show_code_dialog(sort = 'Community'))
+        id_code_action = overlay_menu.addAction("Code Identities")
+        id_code_action.triggered.connect(lambda: self.show_code_dialog(sort = 'Identity'))
 
 
         # Process menu
@@ -2050,6 +2171,37 @@ class ImageViewerWindow(QMainWindow):
     def load_misc(self, sort):
         """Loads various things"""
 
+        def uncork(my_dict, trumper = None):
+
+            if trumper is None:
+                for thing in my_dict:
+                    val = my_dict[thing]
+                    new_val = val[0]
+                    for i in range(1, len(val)):
+                        try:
+                            new_val += f" AND {val[i]}"
+                        except:
+                            break
+                    my_dict[thing] = new_val
+            elif trumper == '-':
+                for key, value in my_dict.items():
+                    my_dict[key] = value[0]
+            else:
+                for thing in my_dict:
+                    val = my_dict[thing]
+                    if trumper in val:
+                        my_dict[thing] = trumper
+                    else:
+                        new_val = val[0]
+                        for i in range(1, len(val)):
+                            try:
+                                new_val += f" AND {val[i]}"
+                            except:
+                                break
+                        my_dict[thing] = new_val
+
+            return my_dict
+
         if sort != 'Merge Nodes':
 
             try:
@@ -2058,13 +2210,32 @@ class ImageViewerWindow(QMainWindow):
                     self,
                     f"Load {sort}",
                     "",
-                    "Spreadsheets (*.xlsx *.csv)"
+                    "Spreadsheets (*.xlsx *.csv *.json)"
                 )
 
                 try:
                     if sort == 'Node Identities':
                         my_network.load_node_identities(file_path = filename)
 
+                        first_value = list(my_network.node_identities.values())[0]  # Check that there are not multiple IDs
+                        if isinstance(first_value, (list, tuple)):
+                            trump_value, ok = QInputDialog.getText(
+                                self,
+                                'Multiple IDs Detected',
+                                'The node identities appear to contain multiple ids per node in a list.\n'
+                                'If you desire one node ID to trump all others, enter it here.\n'
+                                '(Enter "-" to have the first IDs trump all others or press x to skip)'
+                            )
+                            if not ok or trump_value.strip() == '':
+                                trump_value = None
+                            elif trump_value.upper() == '-':
+                                trump_value = '-'
+                            my_network.node_identities = uncork(my_network.node_identities, trump_value)
+                        else:
+                            trump_value = None
+                            my_network.node_identities = uncork(my_network.node_identities, trump_value)
+
+
                         if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
                             try:
                                 self.format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
@@ -2091,9 +2262,13 @@ class ImageViewerWindow(QMainWindow):
 
 
                 except Exception as e:
+                    import traceback
+                    print(traceback.format_exc())
                     print(f"An error has occured: {e}")
 
             except Exception as e:
+                import traceback
+                print(traceback.format_exc())
                 QMessageBox.critical(
                     self,
                     "Error Loading",
@@ -2227,6 +2402,13 @@ class ImageViewerWindow(QMainWindow):
                 except Exception as e:
                     print(f"Error loading node identity table: {e}")
 
+
+            if hasattr(my_network, 'communities') and my_network.communities is not None:
+                try:
+                    self.format_for_upperright_table(my_network.communities, 'NodeID', 'Community', 'Node Communities')
+                except Exception as e:
+                    print(f"Error loading node community table: {e}")
+
         except Exception as e:
             QMessageBox.critical(
                 self,
@@ -2245,7 +2427,7 @@ class ImageViewerWindow(QMainWindow):
                 self,
                 f"Load Network",
                 "",
-                "Spreadsheets (*.xlsx *.csv)"
+                "Spreadsheets (*.xlsx *.csv *.json)"
             )
 
             my_network.load_network(file_path = filename)
@@ -2281,6 +2463,57 @@ class ImageViewerWindow(QMainWindow):
             else:
                 btn.setStyleSheet("")
 
+    def reduce_rgb_dimension(self, array, method='first'):
+        """
+        Reduces a 4D array (Z, Y, X, C) to 3D (Z, Y, X) by dropping the color dimension
+        using the specified method.
+        
+        Parameters:
+        -----------
+        array : numpy.ndarray
+            4D array with shape (Z, Y, X, C) where C is the color channel dimension
+        method : str, optional
+            Method to use for reduction:
+            - 'first': takes the first color channel (default)
+            - 'mean': averages across color channels
+            - 'max': takes maximum value across color channels
+            - 'min': takes minimum value across color channels
+        
+        Returns:
+        --------
+        numpy.ndarray
+            3D array with shape (Z, Y, X)
+        
+        Raises:
+        -------
+        ValueError
+            If input array is not 4D or method is not recognized
+        """
+        if array.ndim != 4:
+            raise ValueError(f"Expected 4D array, got {array.ndim}D array")
+        
+        if method not in ['first', 'mean', 'max', 'min']:
+            raise ValueError(f"Unknown method: {method}")
+        
+        if method == 'first':
+            return array[..., 0]
+        elif method == 'mean':
+            return np.mean(array, axis=-1)
+        elif method == 'max':
+            return np.max(array, axis=-1)
+        else:  # min
+            return np.min(array, axis=-1)
+
+    def confirm_rgb_dialog(self):
+        """Shows a dialog asking user to confirm if image is 2D RGB"""
+        msg = QMessageBox()
+        msg.setIcon(QMessageBox.Icon.Question)
+        msg.setText("Image Format Detection")
+        msg.setInformativeText("Is this a 2D color (RGB/CMYK) image?")
+        msg.setWindowTitle("Confirm Image Format")
+        msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+        return msg.exec() == QMessageBox.StandardButton.Yes
+
     def load_channel(self, channel_index, channel_data=None, data=False, assign_shape = True):
         """Load a channel and enable active channel selection if needed."""
 
@@ -2294,15 +2527,22 @@ class ImageViewerWindow(QMainWindow):
                     "TIFF Files (*.tif *.tiff)"
                 )
                 self.channel_data[channel_index] = tifffile.imread(filename)
-                print(self.channel_data[channel_index].shape)
-                if len(self.channel_data[channel_index].shape) == 2:
-                    #self.channel_data[channel_index] = np.stack((self.channel_data[channel_index], self.channel_data[channel_index]), axis = 0) #currently handle 2d arrays by just making them 3d
+                if len(self.channel_data[channel_index].shape) == 2:  # handle 2d data
                     self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
 
-
             else:
                 self.channel_data[channel_index] = channel_data
 
+            if len(self.channel_data[channel_index].shape) == 3:  # potentially 2D RGB
+                if self.channel_data[channel_index].shape[-1] in (3, 4):  # last dim is 3 or 4
+                    if self.confirm_rgb_dialog():
+                        # User confirmed it's 2D RGB, expand to 4D
+                        self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
+                        
+            if len(self.channel_data[channel_index].shape) == 4 and (channel_index == 0 or channel_index == 1):
+                self.channel_data[channel_index] = self.reduce_rgb_dimension(self.channel_data[channel_index])
+
+
 
             if channel_index == 0:
                 my_network.nodes = self.channel_data[channel_index]
@@ -2746,8 +2986,8 @@ class ImageViewerWindow(QMainWindow):
         dialog = MotherDialog(self)
         dialog.exec()
 
-    def show_code_dialog(self):
-        dialog = CodeDialog(self)
+    def show_code_dialog(self, sort = 'Community'):
+        dialog = CodeDialog(self, sort = sort)
         dialog.exec()
 
 
@@ -4134,16 +4374,19 @@ class NeighborIdentityDialog(QDialog):
 
         layout = QFormLayout(self)
 
-        self.root = QComboBox()
-        self.root.addItems(list(set(my_network.node_identities.values())))  
-        self.root.setCurrentIndex(0)
-        layout.addRow("Root Identity to Search for Neighbor's IDs (search uses nodes of this ID, finds what IDs they connect to", self.root)
+        if my_network.node_identities is not None:
+            self.root = QComboBox()
+            self.root.addItems(list(set(my_network.node_identities.values())))  
+            self.root.setCurrentIndex(0)
+            layout.addRow("Root Identity to Search for Neighbor's IDs (search uses nodes of this ID, finds what IDs they connect to", self.root)
+        else:
+            self.root = None
 
         self.directory = QLineEdit("")
         layout.addRow("Output Directory:", self.directory)
 
         self.mode = QComboBox()
-        self.mode.addItems(["From Network - Based on Absolute Connectivity", "Use Labeled Nodes - Based on Neighborhood Densities"])
+        self.mode.addItems(["From Network - Based on Absolute Connectivity", "Use Labeled Nodes - Based on Morphological Neighborhood Densities"])
         self.mode.setCurrentIndex(0)
         layout.addRow("Mode", self.mode)
 
@@ -4157,21 +4400,33 @@ class NeighborIdentityDialog(QDialog):
 
     def neighborids(self):
 
-        root = self.root.currentText()
+        try:
 
-        directory = self.directory.text() if self.directory.text().strip() else None
+            try:
+                root = self.root.currentText()
+            except:
+                pass
 
-        mode = self.mode.currentIndex()
+            directory = self.directory.text() if self.directory.text().strip() else None
 
-        search = float(self.search.text()) if self.search.text().strip() else 0
+            mode = self.mode.currentIndex()
 
+            search = float(self.search.text()) if self.search.text().strip() else 0
 
-        result, result2, title1, title2 = my_network.neighborhood_identities(root = root, directory = directory, mode = mode, search = search)
 
-        self.parent().format_for_upperright_table(result, 'Node Identity', 'Amount', title = title1)
-        self.parent().format_for_upperright_table(result2, 'Node Identity', 'Proportion', title = title2)
+            result, result2, title1, title2, densities = my_network.neighborhood_identities(root = root, directory = directory, mode = mode, search = search)
 
-        self.accept()
+            self.parent().format_for_upperright_table(result, 'Node Identity', 'Amount', title = title1)
+            self.parent().format_for_upperright_table(result2, 'Node Identity', 'Proportion', title = title2)
+
+            if mode == 1:
+
+                self.parent().format_for_upperright_table(densities, 'Node Identity', 'Density in search/density total', title = f'Clustering Factor of Node Identities with {search} from nodes {root}')
+
+
+            self.accept()
+        except Exception as e:
+            print(f"Error: {e}")
 
 
 
@@ -4521,14 +4776,16 @@ class MotherDialog(QDialog):
 
 class CodeDialog(QDialog):
 
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, sort = 'Community'):
 
         super().__init__(parent)
-        self.setWindowTitle("Community Code Parameters (Will go to Overlay2)")
+        self.setWindowTitle(f"{sort} Code Parameters (Will go to Overlay2)")
         self.setModal(True)
 
         layout = QFormLayout(self)
 
+        self.sort = sort
+
         self.down_factor = QLineEdit("")
         layout.addRow("down_factor (for speeding up overlay generation - optional):", self.down_factor)
 
@@ -4540,7 +4797,7 @@ class CodeDialog(QDialog):
 
 
         # Add Run button
-        run_button = QPushButton("Community Code")
+        run_button = QPushButton(f"{sort} Code")
         run_button.clicked.connect(self.code)
         layout.addWidget(run_button)
 
@@ -4553,16 +4810,27 @@ class CodeDialog(QDialog):
             down_factor = float(self.down_factor.text()) if self.down_factor.text().strip() else None
 
 
-
-            if my_network.communities is None:
-                self.parent().show_partition_dialog()
+            if self.sort == 'Community':
                 if my_network.communities is None:
-                    return
+                    self.parent().show_partition_dialog()
+                    if my_network.communities is None:
+                        return
+            elif my_network.node_identities is None:
+                print("Node identities are not set")
+                return
+
+            if self.sort == 'Community':
+                if mode == 0:
+                    image, output = my_network.extract_communities(down_factor = down_factor)
+                elif mode == 1:
+                    image, output = my_network.extract_communities(color_code = False, down_factor = down_factor)
+            else:
+                if mode == 0:
+                    image, output = my_network.extract_communities(down_factor = down_factor, identities = True)
+                elif mode == 1:
+                    image, output = my_network.extract_communities(color_code = False, down_factor = down_factor, identities = True)
 
-            if mode == 0:
-                image = my_network.extract_communities(down_factor = down_factor)
-            elif mode == 1:
-                image = my_network.extract_communities(color_code = False, down_factor = down_factor)
+            self.parent().format_for_upperright_table(output, f'{self.sort} Id', f'Encoding Val: {self.sort}', 'Legend')
 
 
             self.parent().load_channel(3, image, True)
@@ -4570,6 +4838,8 @@ class CodeDialog(QDialog):
 
         except Exception as e:
             print(f"An error has occurred: {e}")
+            import traceback
+            print(traceback.format_exc())
 
 
 
@@ -5052,7 +5322,7 @@ class DilateDialog(QDialog):
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["Binary Dilation", "Preserve Labels (slower)"])
+        self.mode_selector.addItems(["Binary Dilation", "Preserve Labels (slower)", "Recursive Binary Dilation (Use if the dilation radius is much larger than your objects)"])
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
@@ -5093,12 +5363,18 @@ class DilateDialog(QDialog):
                 self.accept()
                 return
 
+            if accepted_mode == 2:
+                recursive = True
+            else:
+                recursive = False
+
             # Call dilate method with parameters
             result = n3d.dilate(
                 active_data,
                 amount,
                 xy_scale = xy_scale,
                 z_scale = z_scale,
+                recursive = recursive
             )
 
             # Update both the display data and the network object

{nettracer3d-0.2.7 → nettracer3d-0.2.9}/src/nettracer3d/network_analysis.py

@@ -1,5 +1,6 @@
 import pandas as pd
 import networkx as nx
+import json
 import tifffile
 import numpy as np
 from networkx.algorithms import community
@@ -105,6 +106,25 @@ def open_network(excel_file_path):
 
 def read_excel_to_lists(file_path, sheet_name=0):
     """Convert a pd dataframe to lists. Handles both .xlsx and .csv files"""
+    def load_json_to_list(filename):
+        with open(filename, 'r') as f:
+            data = json.load(f)
+        
+        # Convert only numeric strings to integers, leave other strings as is
+        converted_data = [[],[],[]]
+        for i in data[0]:
+            try:
+                converted_data[0].append(int(data[0][i]))
+                converted_data[1].append(int(data[1][i]))
+                try:
+                    converted_data[2].append(int(data[2][i]))
+                except IndexError:
+                    converted_data[2].append(0)
+            except ValueError:
+                converted_data[k] = v
+        
+        return converted_data
+
     if type(file_path) == str:
         # Check file extension
         if file_path.lower().endswith('.xlsx'):
@@ -115,8 +135,11 @@ def read_excel_to_lists(file_path, sheet_name=0):
             # Read the CSV file into a DataFrame without headers
             df = pd.read_csv(file_path, header=None)
             df = df.drop(0)
+        elif file_path.lower().endswith('.json'):
+            df = load_json_to_list(file_path)
+            return df
         else:
-            raise ValueError("File must be either .xlsx or .csv format")
+            raise ValueError("File must be either .xlsx, .csv, or .json format")
     else:
         df = file_path
 
@@ -126,15 +149,15 @@ def read_excel_to_lists(file_path, sheet_name=0):
     for column_name, column_data in df.items():
         # Convert the column values to a list and append to the data_lists
         data_lists.append(column_data.tolist())
-
     master_list = [[], [], []]
     for i in range(0, len(data_lists), 3):
-        master_list[0].extend(data_lists[i])
-        master_list[1].extend(data_lists[i+1])
+        master_list[0].extend([int(x) for x in data_lists[i]])
+        master_list[1].extend([int(x) for x in data_lists[i+1]])
         try:
-            master_list[2].extend(data_lists[i+2])
+            master_list[2].extend([int(x) for x in data_lists[i+2]])
         except IndexError:
-            pass
+            master_list[2].extend([0])  # Note: Changed to list with single int 0
+    print(master_list)
             
     return master_list
 
@@ -402,13 +425,28 @@ def read_centroids_to_dict(file_path):
     Returns:
     dict: Dictionary with first column as keys and next three columns as numpy array values
     """
+    def load_json_to_dict(filename):
+        with open(filename, 'r') as f:
+            data = json.load(f)
+        
+        # Convert only numeric strings to integers, leave other strings as is
+        converted_data = {}
+        for k, v in data.items():
+            try:
+                converted_data[int(k)] = v
+            except ValueError:
+                converted_data[k] = v
+        
+        return converted_data
     # Check file extension
     if file_path.lower().endswith('.xlsx'):
         df = pd.read_excel(file_path)
     elif file_path.lower().endswith('.csv'):
         df = pd.read_csv(file_path)
+    elif file_path.lower().endswith('.json'):
+        df = load_json_to_dict(file_path)
     else:
-        raise ValueError("Unsupported file format. Please provide either .xlsx or .csv file")
+        raise ValueError("Unsupported file format. Please provide either .xlsx, .csv, or .json file")
     
     # Initialize an empty dictionary
     data_dict = {}
@@ -434,13 +472,30 @@ def read_excel_to_singval_dict(file_path):
     Returns:
     dict: Dictionary with first column as keys and second column as values
     """
+    def load_json_to_dict(filename):
+        with open(filename, 'r') as f:
+            data = json.load(f)
+        
+        # Convert only numeric strings to integers, leave other strings as is
+        converted_data = {}
+        for k, v in data.items():
+            try:
+                converted_data[int(k)] = v
+            except ValueError:
+                converted_data[k] = v
+        
+        return converted_data
+
     # Check file extension and read accordingly
     if file_path.lower().endswith('.xlsx'):
         df = pd.read_excel(file_path)
     elif file_path.lower().endswith('.csv'):
         df = pd.read_csv(file_path)
+    elif file_path.lower().endswith('.json'):
+        df = load_json_to_dict(file_path)
+        return df
     else:
-        raise ValueError("Unsupported file format. Please provide either .xlsx or .csv file")
+        raise ValueError("Unsupported file format. Please provide either .xlsx, .csv, or .json file")
     
     # Convert the DataFrame to a dictionary
     data_dict = {}
@@ -521,34 +576,35 @@ def find_centroids(nodes, down_factor = None, network = None):
 
     return centroid_dict
 
-def _save_centroid_dictionary(centroid_dict, filepath = None, index = 'Node ID'):
+def _save_centroid_dictionary(centroid_dict, filepath=None, index='Node ID'):
     # Convert dictionary to DataFrame with keys as index and values as a column
-    #for item in centroid_dict:
-        #representative = centroid_dict[item]
-        #break
-
-    #if len(representative) == 3:
-        #df = pd.DataFrame.from_dict(centroid_dict, orient='index', columns=['Z', 'Y', 'X'])
-    #elif len(representative) == 2:
-        #df = pd.DataFrame.from_dict(centroid_dict, orient='index', columns=['Y', 'X'])
-
     df = pd.DataFrame.from_dict(centroid_dict, orient='index', columns=['Z', 'Y', 'X'])
-
-    # Rename the index to 'Node ID'
+    
+    # Rename the index to specified name
     df.index.name = index
-
+    
     if filepath is None:
-        try:
-            # Save DataFrame to Excel file
-            df.to_excel('centroids.xlsx', engine='openpyxl')
-        except Exception as e:
-            print("Could not save centroids to active directory")
+        base_path = 'centroids'
     else:
+        # Remove file extension if present to use as base path
+        base_path = filepath.rsplit('.', 1)[0]
+    
+    # First try to save as CSV
+    try:
+        csv_path = f"{base_path}.csv"
+        df.to_csv(csv_path)
+        print(f"Successfully saved centroids to {csv_path}")
+        return
+    except Exception as e:
+        print(f"Could not save centroids as CSV: {str(e)}")
+        
+        # If CSV fails, try to save as Excel
         try:
-            # Save DataFrame to Excel file
-            df.to_excel(filepath, engine='openpyxl')
+            xlsx_path = f"{base_path}.xlsx"
+            df.to_excel(xlsx_path, engine='openpyxl')
+            print(f"Successfully saved centroids to {xlsx_path}")
         except Exception as e:
-            print(f"Could not save centroids to {filepath}")
+            print(f"Could not save centroids as XLSX: {str(e)}")
 
 def _find_centroids_GPU(nodes, node_list=None, down_factor=None):
     """Internal use version to get centroids without saving"""
@@ -1174,15 +1230,31 @@ def edge_to_node(network, node_identities = None):
 
 
 def save_singval_dict(dict, index_name, valname, filename):
-
-    #index name goes on the left, valname on the right
+    # Convert dictionary to DataFrame
     df = pd.DataFrame.from_dict(dict, orient='index', columns=[valname])
-
-    # Rename the index to 'Node ID'
+    
+    # Rename the index
     df.index.name = index_name
-
-    # Save DataFrame to Excel file
-    df.to_excel(filename, engine='openpyxl')
+    
+    # Remove file extension if present to use as base path
+    base_path = filename.rsplit('.', 1)[0]
+    
+    # First try to save as CSV
+    try:
+        csv_path = f"{base_path}.csv"
+        df.to_csv(csv_path)
+        print(f"Successfully saved {valname} data to {csv_path}")
+        return
+    except Exception as e:
+        print(f"Could not save as CSV: {str(e)}")
+        
+        # If CSV fails, try to save as Excel
+        try:
+            xlsx_path = f"{base_path}.xlsx"
+            df.to_excel(xlsx_path, engine='openpyxl')
+            print(f"Successfully saved {valname} data to {xlsx_path}")
+        except Exception as e:
+            print(f"Could not save as XLSX: {str(e)}")
 
 
 def rand_net_weighted(num_rows, num_nodes, nodes):

{nettracer3d-0.2.7 → nettracer3d-0.2.9/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.2.7
+Version: 0.2.9
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <boom2449@gmail.com>
 Project-URL: User_Manual, https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link