fusion-tools 2.3.2__tar.gz → 2.4.0__tar.gz

{fusion_tools-2.3.2 → fusion_tools-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fusion-tools
-Version: 2.3.2
+Version: 2.4.0
 Summary: Modular visualization and analysis dashboard creation for high-resolution microscopy images
 Home-page: https://github.com/spborder/fusion-tools
 Author: Sam Border

{fusion_tools-2.3.2 → fusion_tools-2.4.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="fusion-tools",
-    version="2.3.2",
+    version="2.4.0",
     author="Sam Border",
     author_email="sam.border2256@gmail.com",
     description="Modular visualization and analysis dashboard creation for high-resolution microscopy images",

{fusion_tools-2.3.2 → fusion_tools-2.4.0}/src/fusion_tools/components/maps.py

@@ -252,7 +252,20 @@ class SlideMap(MapComponent):
                     ),
                     dl.LayersControl(
                         id = {'type': 'map-layers-control','index': 0},
-                        children = []
+                        children = [
+                            html.Div(
+                                id = {'type': 'map-initial-annotations','index': 0},
+                                children = []
+                            ),
+                            html.Div(
+                                id = {'type': 'map-manual-rois','index': 0},
+                                children = []
+                            ),
+                            html.Div(
+                                id = {'type': 'map-generated-rois','index': 0},
+                                children = []
+                            )
+                        ]
                     ),
                     dl.EasyButton(
                         icon = 'fa-solid fa-arrows-to-dot',
@@ -356,11 +369,14 @@ class SlideMap(MapComponent):
                         var overlaySubProps = overlayProp.name.split(" --> ");
                         var prop_dict = feature.properties;
                         for (let i = 0; i < overlaySubProps.length; i++) {
-                            if (overlaySubProps[i] in prop_dict) {
-                                var prop_dict = prop_dict[overlaySubProps[i]];
-                                var overlayVal = prop_dict;
-                            } else {
-                                var overlayVal = Number.Nan;
+                            if (prop_dict==prop_dict && prop_dict!=null && typeof prop_dict === 'object') {
+                                if (overlaySubProps[i] in prop_dict) {
+                                    var prop_dict = prop_dict[overlaySubProps[i]];
+                                    var overlayVal = prop_dict;
+                                } else {
+                                    prop_dict = Number.Nan;
+                                    var overlayVal = Number.Nan;
+                                }
                             }
                         }
                     } else {
@@ -410,16 +426,19 @@ class SlideMap(MapComponent):
                             var filterSubProps = filter.name.split(" --> ");
                             var prop_dict = feature.properties;
                             for (let j = 0; j < filterSubProps.length; j++) {
-                                if (filterSubProps[j] in prop_dict) {
-                                    var prop_dict = prop_dict[filterSubProps[j]];
-                                    var testVal = prop_dict;
-                                } else {
-                                    returnFeature = returnFeature & false;
+                                if (prop_dict==prop_dict && prop_dict!=null && typeof prop_dict==='object') {
+                                    if (filterSubProps[j] in prop_dict) {
+                                        var prop_dict = prop_dict[filterSubProps[j]];
+                                        var testVal = prop_dict;
+                                    } else {
+                                        prop_dict = Number.Nan;
+                                        returnFeature = returnFeature & false;
+                                    }
                                 }
                             }
                         }
                             
-                        if (filter.range) {
+                        if (filter.range && returnFeature) {
                             if (typeof filter.range[0]==='number') {
                                 if (testVal < filter.range[0]) {
                                     returnFeature = returnFeature & false;
@@ -471,7 +490,9 @@ class SlideMap(MapComponent):
                 Input({'type': 'slide-select-drop','index': ALL},'value')
             ],
             [
-                Output({'type': 'map-layers-control','index': MATCH},'children'),
+                Output({'type': 'map-initial-annotations','index': MATCH},'children'),
+                Output({'type': 'map-manual-rois','index': MATCH},'children'),
+                Output({'type': 'map-generated-rois','index': MATCH},'children'),
                 Output({'type': 'map-annotations-store','index':MATCH},'data'),
                 Output({'type': 'map-tile-layer-holder','index': MATCH},'children'),
                 Output({'type': 'map-slide-information','index': MATCH},'data')
@@ -498,7 +519,7 @@ class SlideMap(MapComponent):
                 Input({'type':'upload-shape-data','index': ALL},'contents')
             ],
             [
-                Output({'type': 'map-layers-control','index': MATCH},'children'),
+                Output({'type': 'map-manual-rois','index': MATCH},'children'),
                 Output({'type': 'map-annotations-store','index': MATCH},'data')
             ],
             [
@@ -506,6 +527,8 @@ class SlideMap(MapComponent):
                 State({'type': 'base-layer','index': ALL},'children'),
                 State({'type': 'feature-lineColor','index': ALL},'value'),
                 State({'type': 'adv-overlay-colormap','index': ALL},'value'),
+                State({'type': 'manual-roi-separate-switch','index': ALL},'checked'),
+                State({'type': 'manual-roi-summarize-switch','index': ALL},'checked')
             ]
         )(self.add_manual_roi)
 
@@ -734,7 +757,11 @@ class SlideMap(MapComponent):
         geo_annotations = json.dumps(geo_annotations)
         new_slide_info = json.dumps(new_slide_info)
 
-        return new_layer_children, geo_annotations, new_tile_layer, new_slide_info
+        # Updating manual and generated ROIs divs
+        manual_rois = []
+        gen_rois = []
+
+        return new_layer_children, manual_rois, gen_rois, geo_annotations, new_tile_layer, new_slide_info
 
     def upload_shape(self, upload_clicked, is_open):
 
@@ -786,6 +813,45 @@ class SlideMap(MapComponent):
             )
 
             return return_table
+        
+        def make_sub_accordion(input_data: Union[list,dict], main_list: list = [], sub_accordion_list:list = [],main_title:str=''):
+            """Recursively generating sub-accordion objects for nested properties
+
+            :param input_dict: Input dictionary containing nested and non-nested key/value pairs
+            :type input_dict: dict
+            :param sub_accordion_list: List of sub-accordions, defaults to []
+            :type sub_accordion_list: list, optional
+            """
+            for idx,in_data in enumerate(input_data):
+                title = list(in_data.keys())[0]
+                non_nested_data = [{'Sub-Property':key, 'Value': val} for key,val in in_data[title].items() if not type(val) in [list,dict]]
+                nested_data = [{key:val} for key,val in in_data[title].items() if type(val)==dict]
+                if len(non_nested_data)>0:
+                    sub_accordion_list.append(
+                        dbc.AccordionItem([
+                            html.Div([
+                                make_dash_table(pd.DataFrame.from_records(non_nested_data))
+                            ])
+                        ],title = title)
+                    )
+                if len(nested_data)>0:
+                    main_title = title
+                    main_list, sub_accordion_list = make_sub_accordion(nested_data, main_list, sub_accordion_list,main_title)
+                    print(f'len(sub_accordion_list): {len(sub_accordion_list)}')
+
+            if len(sub_accordion_list)>0:
+                main_list.append(
+                    dbc.AccordionItem(
+                        children = dbc.Accordion(sub_accordion_list),
+                        title = main_title
+                    )
+                )
+            sub_accordion_list = []
+            main_title = ''
+            
+            return main_list, sub_accordion_list
+
+
 
         accordion_children = []
         all_properties = list(clicked['properties'].keys())
@@ -802,19 +868,10 @@ class SlideMap(MapComponent):
         )
 
         # Now loading the dict properties as sub-accordions
-        dict_properties = [i for i in all_properties if type(clicked['properties'][i])==dict]
-        for d in dict_properties:
-            sub_properties = clicked['properties'][d]
-            sub_prop_record = [{'SubProperty': i, 'Value': j} for i,j in sub_properties.items() if not type(j) in [list,dict]]
-
-            if len(sub_prop_record)>0:
-                accordion_children.append(
-                    dbc.AccordionItem([
-                        html.Div([
-                            make_dash_table(pd.DataFrame.from_records(sub_prop_record))
-                        ])
-                    ],title = d)
-                )
+        sub_properties = [{i:clicked['properties'][i]} for i in clicked['properties'] if type(clicked['properties'][i])==dict]
+        test_sub_accordions, _ = make_sub_accordion(sub_properties)
+        if len(test_sub_accordions)>0:
+            accordion_children.extend(test_sub_accordions)
 
         # If this is a manual ROI then add a download option:
         if 'Manual' in clicked['properties']['name']:
@@ -838,7 +895,9 @@ class SlideMap(MapComponent):
 
         popup_div = html.Div(
             dbc.Accordion(
-                children = accordion_children
+                children = accordion_children,
+                start_collapsed=True,
+                style = {'maxHeight': '800px','overflow': 'scroll','width': '400px'}
             )
         )
 
@@ -916,7 +975,7 @@ class SlideMap(MapComponent):
 
         return annotation_components
 
-    def add_manual_roi(self,new_geojson:list, uploaded_shape: list, current_annotations:list, frame_layers:list, line_colors:list, colormap:list) -> list:
+    def add_manual_roi(self,new_geojson:list, uploaded_shape: list, current_annotations:list, frame_layers:list, line_colors:list, colormap:list, separate_switch: list, summarize_switch: list) -> list:
         """Adding a manual region of interest (ROI) to the SlideMap using dl.EditControl() tools including polygon, rectangle, and markers.
 
         :param new_geojson: Incoming GeoJSON object that is emitted by dl.EditControl() following annotation on SlideMap
@@ -941,19 +1000,29 @@ class SlideMap(MapComponent):
         current_annotations = json.loads(get_pattern_matching_value(current_annotations))
 
         colormap = get_pattern_matching_value(colormap)
+        separate_switch = get_pattern_matching_value(separate_switch)
+        summarize_switch = get_pattern_matching_value(summarize_switch)
+        separate_switch = separate_switch if not separate_switch is None else False
+        summarize_switch = summarize_switch if not summarize_switch is None else False
 
         if colormap is None or len(colormap)==0:
             colormap = 'blue->red'
         
         # All but the last one which holds the manual ROIs
-        initial_annotations = [i for i in current_annotations if not 'Manual' in i['properties']['name']]
+        initial_annotations = [i for i in current_annotations if not any([j in i['properties']['name'] for j in ['Manual','Filtered','Upload']])]
         # Current manual rois (used for determining if a new ROI has been created/edited)
         annotation_names = [i['properties']['name'] for i in current_annotations]
         manual_roi_idxes = [0]+[int(i.split(' ')[-1]) for i in annotation_names if 'Manual' in i]
+
         manual_rois = [i for i in current_annotations if 'Manual' in i['properties']['name']]
 
+        # The three different types of ROIs present on maps
+        manual_roi_idx = [idx for idx,i in enumerate(current_annotations) if 'Manual' in i['properties']['name']]
+        #filtered_rois = [idx for idx,i in enumerate(current_annotations) if 'Filtered' in i['properties']['name']]
+        #uploaded_rois = [idx for idx,i in enumerate(current_annotations) if 'Upload' in i['properties']['name']]
+
         # Initializing layers with partial update object
-        new_children = Patch()
+        new_manual_rois = Patch()
         added_rois = []
         added_roi_names = []
         deleted_rois = []
@@ -986,7 +1055,7 @@ class SlideMap(MapComponent):
                     # Aggregate if any initial annotations are present
                     if len(initial_annotations)>0:
                         # Spatial aggregation performed just between individual manual ROIs and initial annotations (no manual ROI to manual ROI aggregation)
-                        new_roi = spatially_aggregate(new_roi, initial_annotations)
+                        new_roi = spatially_aggregate(new_roi, initial_annotations,separate=separate_switch,summarize=summarize_switch)
                     
                     added_rois.append(new_roi)
                     added_roi_names.append(new_roi_name)
@@ -1014,17 +1083,17 @@ class SlideMap(MapComponent):
                 new_roi_name = uploaded_roi['properties']['name']
                 if len(initial_annotations)>0:
                     # Spatial aggregation performed just between individual manual ROIs and initial annotations (no manual ROI to manual ROI aggregation)
-                    new_roi = spatially_aggregate(uploaded_roi, initial_annotations)
+                    new_roi = spatially_aggregate(uploaded_roi, initial_annotations,separate=separate_switch,summarize=summarize_switch)
 
                 added_rois.append(new_roi)
                 added_roi_names.append(new_roi_name)
                 manual_roi_idxes.append(max(manual_roi_idxes)+1)
 
-
         # Checking for deleted manual ROIs
-        for m_idx,m in enumerate(manual_rois):
+        for m_idx,(m,man_idx) in enumerate(zip(manual_rois,manual_roi_idx)):
             if not m['features'][0]['geometry'] in [j['geometry'] for j  in new_geojson['features']]:
-                deleted_rois.append(m_idx)
+                # Adding both the index in the manual-rois layer and the index in the current annotations layer
+                deleted_rois.append((m_idx,man_idx))
 
         operation = False
         if len(added_rois)>0:
@@ -1034,22 +1103,22 @@ class SlideMap(MapComponent):
             new_layers = self.make_geojson_layers(
                 added_rois,added_roi_names,[len(initial_annotations)+max(manual_roi_idxes)],line_colors,colormap
             )
-            new_children.extend(new_layers)
+            new_manual_rois.extend(new_layers)
 
             current_annotations.extend(added_rois)
         
         if len(deleted_rois)>0:
             operation = True
-            for d_idx,d in enumerate(deleted_rois):
-                del new_children[(d-d_idx)+len(frame_layers)+len(initial_annotations)]
-                del current_annotations[(d-d_idx)+len(initial_annotations)]
+            for d_idx,(man_d,current_d) in enumerate(deleted_rois):
+                del new_manual_rois[man_d-d_idx]
+                del current_annotations[current_d-d_idx]
 
         annotations_data = json.dumps(current_annotations)
 
         if not operation:
-            new_children = no_update
+            new_manual_rois = no_update
 
-        return new_children, annotations_data
+        return new_manual_rois, annotations_data
 
     def update_image_overlay_transparency(self, new_opacity: float):
         """Update transparency of image overlay component

{fusion_tools-2.3.2 → fusion_tools-2.4.0}/src/fusion_tools/components/tools.py

@@ -55,7 +55,7 @@ class OverlayOptions(Tool):
     :type Tool: None
     """
     def __init__(self,
-                 ignore_list: list = [],
+                 ignore_list: list = ["_id", "_index"],
                  property_depth: int = 4
                  ):
         """Constructor method
@@ -85,7 +85,7 @@ class OverlayOptions(Tool):
             ]
         )
 
-        self.js_namespace = Namespace("fusionTools","default")
+        self.js_namespace = Namespace("fusionTools","slideMap")
 
         # Add callbacks here
         self.get_callbacks()
@@ -280,6 +280,36 @@ class OverlayOptions(Tool):
                                         ])
                                     ]
                                 ),
+                                dbc.AccordionItem(
+                                    title = dcc.Markdown('*Manual ROI Options*'),
+                                    children = [
+                                        dbc.Card([
+                                            dbc.CardBody([
+                                                # Whether to separate structures or not
+                                                # Whether to summarize or not
+                                                dmc.Switch(
+                                                    size = 'lg',
+                                                    radius = 'lg',
+                                                    label = 'Separate Intersecting Structures',
+                                                    onLabel="ON",
+                                                    offLabel="OFF",
+                                                    description = "Separates aggregated properties by which structure they are derived from",
+                                                    id = {'type': 'manual-roi-separate-switch','index':0}
+                                                ),
+                                                html.Hr(),
+                                                dmc.Switch(
+                                                    size = 'lg',
+                                                    radius = 'lg',
+                                                    label = "Summarize Aggregated Properties",
+                                                    onLabel = "ON",
+                                                    offLabel = "OFF",
+                                                    description = "Whether to report summaries of aggregated properties or just the MEAN",
+                                                    id = {'type': 'manual-roi-summarize-switch','index': 0}
+                                                )
+                                            ])
+                                        ])
+                                    ]
+                                ),
                                 dbc.AccordionItem(
                                     title = dcc.Markdown('*Export Layers*'),
                                     children = [
@@ -460,7 +490,7 @@ class OverlayOptions(Tool):
                     dmc.ColorPicker(
                         id = {'type': f'{self.component_prefix}-feature-lineColor','index': f_idx},
                         format = 'hex',
-                        value = '#FFFFFF',
+                        value = '#%02x%02x%02x' % (np.random.randint(0,255),np.random.randint(0,255),np.random.randint(0,255)),
                         fullWidth=True
                     ),
                     dbc.Button(
@@ -981,7 +1011,7 @@ class PropertyViewer(Tool):
     """
     def __init__(self,
                  ignore_list: list = [],
-                 property_depth: int = 4
+                 property_depth: int = 6
                  ):
         """Constructor method
 
@@ -1584,7 +1614,7 @@ class PropertyPlotter(Tool):
     """
     def __init__(self,
                  ignore_list: list = [],
-                 property_depth: int = 4
+                 property_depth: int = 6
                  ):
         """Constructor method
 
@@ -2139,7 +2169,7 @@ class PropertyPlotter(Tool):
                 text = '<br>'.join(
                     textwrap.wrap(
                         f'{property_column}',
-                        width=15
+                        width=80
                     )
                 ),
                 font = dict(size = 10)
@@ -2148,7 +2178,7 @@ class PropertyPlotter(Tool):
                 text = '<br>'.join(
                     textwrap.wrap(
                         label_col,
-                        width=15
+                        width=80
                     )
                 ) if not label_col is None else 'Group',
                 font = dict(size = 10)
@@ -2184,7 +2214,7 @@ class PropertyPlotter(Tool):
                     title = '<br>'.join(
                         textwrap.wrap(
                             f'Scatter plot of {plot_cols[0]} and {plot_cols[1]} labeled by {label_col}',
-                            width = 30
+                            width = 60
                             )
                         )
                 )
@@ -2233,7 +2263,7 @@ class PropertyPlotter(Tool):
                     title = '<br>'.join(
                         textwrap.wrap(
                             f'Scatter plot of {plot_cols[0]} and {plot_cols[1]}',
-                            width = 30
+                            width = 60
                             )
                         )
                 )

{fusion_tools-2.3.2 → fusion_tools-2.4.0}/src/fusion_tools/feature_extraction.py

@@ -97,7 +97,7 @@ class ParallelFeatureExtractor:
         if not self.mask_names is None:
             convert_key = {f'Mask {float(idx+1)}': i for idx,i in enumerate(self.mask_names)}
         if not self.channel_names is None:
-            convert_key = convert_key | {f'Channel {float(idx+1)}': i for idx,i in enumerate(self.channel_names)}
+            convert_key = convert_key | {f'Channel {idx}': i for idx,i in enumerate(self.channel_names)}
 
         def convert_dict_key(pre_convert):
             if pre_convert in convert_key:
@@ -308,10 +308,10 @@ def color_features(image:np.ndarray, mask: np.ndarray, coords:list)->dict:
         mask_regions = (mask==m)
         masked_channels = image[mask_regions>0]
 
-        mean_vals = np.nanmean(masked_channels,axis=0).tolist()
-        median_vals = np.nanmedian(masked_channels,axis=0).tolist()
-        max_vals = np.nanmedian(masked_channels,axis=0).tolist()
-        std_vals = np.nanstd(masked_channels,axis=0).tolist()
+        mean_vals = np.nanmean(masked_channels,axis=0).astype(float).tolist()
+        median_vals = np.nanmedian(masked_channels,axis=0).astype(float).tolist()
+        max_vals = np.nanmedian(masked_channels,axis=0).astype(float).tolist()
+        std_vals = np.nanstd(masked_channels,axis=0).astype(float).tolist()
 
         feature_values[f'Mask {m}'] = {}
         for c_idx,(m1,m2,m3,s) in enumerate(zip(mean_vals, median_vals, max_vals, std_vals)):
@@ -350,7 +350,7 @@ def texture_features(image:np.ndarray, mask:np.ndarray, coords: list)->dict:
             for t in texture_features:
                 t_value = graycoprops(texture_matrix,t.lower())[0][0]
                 
-                feature_values[f'Mask {m}'][f'Channel {c}'][t] = t_value
+                feature_values[f'Mask {m}'][f'Channel {c}'][t] = float(t_value)
 
     return feature_values
 
@@ -383,10 +383,10 @@ def morphological_features(image:np.ndarray,mask:np.ndarray,coords:list)->dict:
         feature_values[f'Mask {m}'] = {'Count': props.shape[0]}
         for p in props.columns.tolist():
             feature_values[f'Mask {m}'][p] = {
-                'Mean': props[p].mean(),
-                'Median': props[p].median(),
-                'Max': props[p].max(),
-                'Min': props[p].min()
+                'Mean': float(props[p].mean()),
+                'Median': float(props[p].median()),
+                'Max': float(props[p].max()),
+                'Min': float(props[p].min())
             }
 
     return feature_values
@@ -413,11 +413,11 @@ def relative_distance(input_shapes:dict, other_shapes:Union[dict,list])->list:
             all_dist.extend(other_fc.distance(shape(f['geometry'])))
 
         distance_stats.append({
-            'Min': np.min(all_dist),
-            'Max': np.max(all_dist),
-            'Mean': np.mean(all_dist),
-            'Median': np.median(all_dist),
-            'Std': np.std(all_dist)
+            'Min': float(np.min(all_dist)),
+            'Max': float(np.max(all_dist)),
+            'Mean': float(np.mean(all_dist)),
+            'Median': float(np.median(all_dist)),
+            'Std': float(np.std(all_dist))
         })
 
     return distance_stats

{fusion_tools-2.3.2 → fusion_tools-2.4.0}/src/fusion_tools/tileserver.py

@@ -74,16 +74,16 @@ class LocalTileServer(TileServer):
     def __len__(self):
         return len(self.tile_sources)
     
-    def add_new_image(self,new_image_path:str, new_annotations:Union[str,list,dict,None]):
+    def add_new_image(self,new_image_path:str, new_annotations:Union[str,list,dict,None], new_metadata:Union[dict,None] = None):
 
         self.local_image_paths.append(new_image_path)
         self.names.append(new_image_path.split(os.sep)[-1])
         new_tile_source = large_image.open(new_image_path)
-        new_metadata = new_tile_source.getMetadata()
+        new_tiles_metadata = new_tile_source.getMetadata()
 
         # Treating 3-frame images as RGB by default
-        if 'frames' in new_metadata:
-            if len(new_metadata['frames'])==3:
+        if 'frames' in new_tiles_metadata:
+            if len(new_tiles_metadata['frames'])==3:
                 new_tile_source = large_image.open(
                     new_image_path,
                     style = {
@@ -98,7 +98,10 @@ class LocalTileServer(TileServer):
                 )
 
         self.tile_sources.append(new_tile_source)
-        self.tiles_metadatas.append(new_tile_source.getMetadata())
+        if not new_metadata is None:
+            self.tiles_metadata.append(new_tiles_metadata | new_metadata)
+        else:
+            self.tiles_metadatas.append(new_tiles_metadata)
 
         if not new_annotations is None:
             if type(new_annotations)==str:

{fusion_tools-2.3.2 → fusion_tools-2.4.0}/src/fusion_tools/utils/shapes.py

@@ -671,7 +671,7 @@ def find_intersecting(geo_source:Union[dict,str], geo_query:Polygon, return_prop
     elif return_shapes:
         return geo_intersect_geojson
 
-def spatially_aggregate(child_geo:dict, parent_geos: list, separate: bool = True, summarize: bool = True, ignore_list: list = []):
+def spatially_aggregate(child_geo:dict, parent_geos: list, separate: bool = True, summarize: bool = True, ignore_list: list = ["_id","_index"]):
     """Aggregate intersecting feature properties to a provided GeoJSON 
 
     :param child_geo: GeoJSON object that is receiving aggregated properties

{fusion_tools-2.3.2 → fusion_tools-2.4.0}/src/fusion_tools/utils/stats.py

@@ -196,17 +196,3 @@ def run_wilcox_rank_sum(data_df: pd.DataFrame, label_col:str, p_val_thresh: floa
     return results_list
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-

{fusion_tools-2.3.2 → fusion_tools-2.4.0}/src/fusion_tools/visualization/components.py

@@ -46,6 +46,7 @@ class Visualization:
     def __init__(self,
                  local_slides: Union[list,str,None] = None,
                  local_annotations: Union[list,dict,None] = None,
+                 slide_metadata: Union[list,dict,None] = None,
                  tileservers: Union[list,TileServer,None] = None,
                  components: list = [],
                  app_options: dict = {},
@@ -53,13 +54,24 @@ class Visualization:
                  ):
         """Constructor method
 
-        :param components: List of rows, columns, and tabs to include current visualization session
-        :type components: list
-        :param app_options: Additional application options, defaults to {}
+        :param local_slides: Filepath for individual slide or list of filepaths stored locally, defaults to None
+        :type local_slides: Union[list,str,None], optional
+        :param local_annotations: List of processed annotations or filepaths for annotations stored locally (aligns with local_slides), defaults to None
+        :type local_annotations: Union[list,dict,None], optional
+        :param slide_metadata: List or single dictionary containing slide-level metadata keys and values, defaults to None
+        :type slide_metadata: Union[list,dict,None], optional
+        :param tileservers: Single tileserver or multiple tileservers, defaults to None
+        :type tileservers: Union[list,TileServer,None], optional
+        :param components: List of components in layout format (rows-->columns-->tabs for nested lists), defaults to []
+        :type components: list, optional
+        :param app_options: Additional options for the running visualization session, defaults to {}
         :type app_options: dict, optional
+        :param linkage: Which levels of components are linked through callbacks (can be 'row','col',or 'tab'), defaults to 'row'
+        :type linkage: str, optional
         """
 
         self.local_slides = local_slides
+        self.slide_metadata = slide_metadata
         self.tileservers = tileservers
         self.local_annotations = local_annotations
         self.components = components
@@ -128,19 +140,23 @@ class Visualization:
         if not self.local_slides is None:
             if self.local_annotations is None:
                 self.local_annotations = [None]*len(self.local_slides)
+            
+            if self.slide_metadata is None:
+                self.slide_metadata = [None]*len(self.local_slides)
 
             self.local_tile_server = LocalTileServer(
                 tile_server_port=self.app_options['port'] if not self.app_options['jupyter'] else self.app_options['port']+10,
                 host = self.app_options['host']
             )
 
-            for s_idx,(s,anns) in enumerate(zip(self.local_slides,self.local_annotations)):
+            for s_idx,(s,anns,meta) in enumerate(zip(self.local_slides,self.local_annotations,self.slide_metadata)):
                 slide_dict = {}
                 if not s is None:
                     # Adding this slide to list of local slides
                     self.local_tile_server.add_new_image(
                         new_image_path = s,
-                        new_annotations = anns
+                        new_annotations = anns,
+                        new_metadata = meta
                     )
 
                     slide_dict = {
@@ -183,6 +199,15 @@ class Visualization:
                         'metadata_url': t.metadata_url,
                         'annotations_url': t.annotations_url
                     })
+                elif type(t)==CustomTileServer:
+                    slide_store.append({
+                        'start_idx': (s_idx+t_idx+t),
+                        'name': t.name,
+                        'tiles_url': t.tiles_url,
+                        'regions_url': t.regions_url if hasattr(t,'regions_url') else None,
+                        'metadata_url': t.metadata_url if hasattr(t,'metadata_url') else None,
+                        'annotations_url': t.annotations_url if hasattr(t,'annotations_url') else None
+                    })
 
         return slide_store
 

{fusion_tools-2.3.2 → fusion_tools-2.4.0}/src/fusion_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fusion-tools
-Version: 2.3.2
+Version: 2.4.0
 Summary: Modular visualization and analysis dashboard creation for high-resolution microscopy images
 Home-page: https://github.com/spborder/fusion-tools
 Author: Sam Border

{fusion_tools-2.3.2 → fusion_tools-2.4.0}/src/fusion_tools.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ tests/test_classification_model.py
 tests/test_custom_component.py
 tests/test_dataset_classes.py
 tests/test_extract_nested_prop.py
+tests/test_extract_recursive.py
 tests/test_feature_annotation.py
 tests/test_feature_extraction.py
 tests/test_generate_property_dict.py
@@ -36,6 +37,7 @@ tests/test_image_overlay.py
 tests/test_model_train.py
 tests/test_multiframe_rgb.py
 tests/test_multiframeslidemap.py
+tests/test_process.py
 tests/test_property_plotter.py
 tests/test_read_anndata.py
 tests/test_remote_slide_annotations.py

fusion_tools-2.4.0/tests/test_extract_recursive.py

@@ -0,0 +1,62 @@
+"""test recursive property extraction
+"""
+import json
+
+def read_dict_list(dict_list,main_list = [],sub_list = None):
+    for d in dict_list:
+        if type(d)==dict:
+            title = list(d.keys())[0]
+            print(f'title: {title}')
+
+            nested = [{key:val} for key,val in d[title].items() if type(val)==dict]
+            non_nested = [{'SubProperty': key, 'Value': val} for key,val in d[title].items() if not type(val)==dict]
+            main_list.append(non_nested)
+            read_dict_list(nested,main_list,[])
+    return main_list
+
+
+def main():
+
+    test_list = [
+        {
+            'main_prop': {
+                'sub_prop1': {},
+                'sub_prop2': {
+                    'sub_subprop1': 2
+                },
+                'sub_prop3': {
+                    'sub_subprop1': {
+                        'sub_key': 'sub_val',
+                        'sub_key2': 'sub_val2'
+                    },
+                    'sub_subprop2': {
+                        'sub_sub_subprop1': 4
+                    }
+                }
+            }
+        },
+        {
+            'main_prop2': {
+                'sub_prop2': {
+                    'key1': 'val1',
+                    'key2': 'val2',
+                    'key3': 'val3',
+                    'nested_key': {
+                        'n_key1': 'n_val1',
+                        'n_key2': 'n_val2'
+                    }
+                }
+            }
+        }
+    ]
+
+    print(json.dumps(test_list,indent=4))
+
+    print(read_dict_list(test_list))
+
+
+
+if __name__=='__main__':
+    main()
+
+

{fusion_tools-2.3.2 → fusion_tools-2.4.0}/tests/test_feature_extraction.py

@@ -151,6 +151,8 @@ def main():
         ],
         preprocess = None,
         sub_mask = lambda image,mask: stain_mask(image,mask),
+        mask_names = ['Nuclei','Eosinophilic','Luminal Space'],
+        channel_names = ['Red','Green','Blue'],
         n_jobs = 4,
         verbose = True
     )
@@ -158,6 +160,8 @@ def main():
     feature_df = feature_extractor.start(annotations[0]['features'])
 
     print(feature_df)
+    import json
+    print(json.dumps(feature_df.to_dict('records'),indent=4))
     feature_df.to_csv('.\\tests\\test_features.csv')
 
 

fusion_tools-2.4.0/tests/test_process.py

@@ -0,0 +1,395 @@
+# %% [markdown]
+# ### Making annotations for *10x Visium* data
+# 
+# #### Step 1: (*external*) Convert *.RDS* file (SpaceRanger output) to *.h5ad*
+# - This can be done using Seurat and SeuratDisk to go from *SeuratObject* -> *.h5Seurat* -> *.h5ad* see [this page](https://mojaveazure.github.io/seurat-disk/articles/convert-anndata.html) although the spot coordinates have to be added to the `seuratObject` manually in order to be added to the *.h5ad* file.
+#     - Do this using:
+#     
+#         `seuratObject@meta.data[["spot_coordinates"]] <- cbind(seuratObject@meta.data, seuratObject@images[["slice1"]]@coordinates)`
+# 
+#     - **Important**:
+#         - `Convert` will only save the *DefaultAssay* to the *X* matrix and will ignore all other assays. You can get around this by resetting the *DefaultAssay*:
+# 
+#             `DefaultAssay(seuratObject) <- "predsubclassl2"`
+#     
+
+# %% [markdown]
+# #### Step 2: Create annotation files using *fusion-tools*
+
+# %%
+#%pip install fusion-tools[interactive]==2.3.3
+
+# %%
+import os
+import sys
+import json
+sys.path.append('./src/')
+
+import numpy as np
+import pandas as pd
+
+import anndata as ad
+from tqdm import tqdm
+import uuid
+
+from shapely.geometry import Point, shape, Polygon
+from shapely.ops import unary_union
+
+from fusion_tools.utils.shapes import load_visium, spatially_aggregate
+from fusion_tools.utils.omics import group_subtypes, selective_aggregation
+
+visium_path = "..\\..\\Test Upload\\new Visium\\V12U21-010_XY02_21-0069.h5ad"
+
+# This function will be in the next released version
+spot_annotations = load_visium(visium_path)
+anndata_object = ad.read_h5ad(visium_path)
+
+
+# %% [markdown]
+# ## Creating Cell Hierarchical labels
+
+# %%
+cell_groups_path = "..\\..\\Test Upload\\new Visium\\Supplementary Tables Version 1 05-2024.xlsx"
+cell_groups = pd.read_excel(cell_groups_path,engine='openpyxl',sheet_name='Table S - sn annot',skiprows=range(4),index_col=0)
+cell_groups = cell_groups[cell_groups["v2.subclass.l1"].notna()]
+
+l1_types = cell_groups["v2.subclass.l1"].dropna(how='all').unique()
+main_cell_grouping = {}
+for l1 in l1_types:
+    l2_types = cell_groups[cell_groups["v2.subclass.l1"].str.contains(l1)]["v2.subclass.l2"].tolist()
+    main_cell_grouping[l1] = l2_types
+
+print(json.dumps(main_cell_grouping,indent=4))
+
+
+# %% [markdown]
+# ## Adding Seurat Clusters as a sub-property for each spot
+
+# %%
+# Aligning annotations with cell subtype values and Seurat clusters (stored in obs):
+pred_l2 = anndata_object.to_df().round(decimals = 5)
+clusters = anndata_object.obs['seurat_clusters'].values
+for row in range(pred_l2.shape[0]):
+    row_data = pred_l2.iloc[row,:].to_dict()
+    del row_data['max']
+
+    spot_annotations['features'][row]['properties'] = spot_annotations['features'][row]['properties'] | {'L2 Cell Types': row_data, 'Seurat Cluster': str(clusters[row])}
+    spot_annotations['features'][row]['properties'] = spot_annotations['features'][row]['properties'] | {"L1 Cell Types": group_subtypes({"L2": row_data},"L2",main_cell_grouping,keep_zeros=True)}
+       
+
+
+# %% [markdown]
+# ## Extracting simple morphometrics for spots
+
+# %%
+from PIL import Image
+from io import BytesIO
+import large_image
+from skimage.filters import threshold_otsu
+from skimage.segmentation import watershed
+from skimage import exposure
+from skimage.color import rgb2hsv
+import scipy.ndimage as ndi
+from skimage.morphology import remove_small_holes, remove_small_objects
+from skimage.measure import label, find_contours
+from skimage.feature import peak_local_max
+import matplotlib.pyplot as plt
+
+from fusion_tools.feature_extraction import (
+    ParallelFeatureExtractor, distance_transform_features, color_features,
+    texture_features, morphological_features
+)
+
+if False:
+    # define sub-compartment segmentation function
+    def stain_mask(image,mask):
+
+        seg_params = [
+            {
+                'name': 'Nuclei',
+                'threshold': 150,
+                'min_size': 40
+            },
+            {
+                'name': 'Eosinophilic',
+                'threshold': 30,
+                'min_size': 20
+            },
+            {
+                'name': 'Luminal Space',
+                'threshold': 0,
+                'min_size': 0
+            }
+        ]
+
+        image_shape = np.shape(image)
+
+        sub_comp_image = np.zeros((image_shape[0],image_shape[1],3))
+        remainder_mask = np.ones((image_shape[0],image_shape[1]))
+
+        hsv_image = np.uint8(255*rgb2hsv(image))
+        hsv_image = hsv_image[:,:,1]
+
+        for idx,param in enumerate(seg_params):
+
+            # Check for if the current sub-compartment is nuclei
+            if param['name'].lower()=='nuclei':
+                # Using the inverse of the value channel for nuclei
+                h_image = 255-np.uint8(255*rgb2hsv(image)[:,:,2])
+                h_image = np.uint8(255*exposure.equalize_hist(h_image))
+
+                remaining_pixels = np.multiply(h_image,remainder_mask)
+                masked_remaining_pixels = np.multiply(remaining_pixels,mask)
+                #masked_remaining_pixels = remaining_pixels
+
+                # Applying manual threshold
+                masked_remaining_pixels[masked_remaining_pixels<=param['threshold']] = 0
+                masked_remaining_pixels[masked_remaining_pixels>0] = 1
+
+                # Area threshold for holes is controllable for this
+                sub_mask = remove_small_holes(masked_remaining_pixels>0,area_threshold=10)
+                sub_mask = sub_mask>0
+                # Watershed implementation from: https://scikit-image.org/docs/stable/auto_examples/segmentation/plot_watershed.html
+                distance = ndi.distance_transform_edt(sub_mask)
+                labeled_mask, _ = ndi.label(sub_mask)
+                coords = peak_local_max(distance,footprint=np.ones((3,3)),labels = labeled_mask)
+                watershed_mask = np.zeros(distance.shape,dtype=bool)
+                watershed_mask[tuple(coords.T)] = True
+                markers, _ = ndi.label(watershed_mask)
+                sub_mask = watershed(-distance,markers,mask=sub_mask)
+                sub_mask = sub_mask>0
+
+                # Filtering out small objects again
+                sub_mask = remove_small_objects(sub_mask,param['min_size'])
+
+            else:
+
+                remaining_pixels = np.multiply(hsv_image,remainder_mask)
+                masked_remaining_pixels = np.multiply(remaining_pixels,mask)
+                #masked_remaining_pixels = remaining_pixels
+
+                # Applying manual threshold
+                masked_remaining_pixels[masked_remaining_pixels<=param['threshold']] = 0
+                masked_remaining_pixels[masked_remaining_pixels>0] = 1
+
+                # Filtering by minimum size
+                small_object_filtered = (1/255)*np.uint8(remove_small_objects(masked_remaining_pixels>0,param['min_size']))
+
+                sub_mask = small_object_filtered
+
+            sub_comp_image[sub_mask>0,idx] = 1
+            remainder_mask -= sub_mask>0
+
+        # Assigning remaining pixels within the boundary mask to the last sub-compartment
+        #remaining_pixels = np.multiply(mask,remainder_mask)
+        remaining_pixels = remainder_mask
+        sub_comp_image[remaining_pixels>0,idx] = 1
+
+        final_mask = np.zeros_like(remainder_mask)
+        final_mask += sub_comp_image[:,:,0]
+        final_mask += 2*sub_comp_image[:,:,1]
+        final_mask += 3*sub_comp_image[:,:,2]
+
+        return final_mask
+
+
+    # Define feature extractor class
+    feature_extractor = ParallelFeatureExtractor(
+        image_source = "..\\..\\Test Upload\\new Visium\\V12U21-010_XY02_21-0069.tif",
+        feature_list = [
+                lambda image,mask,coords: distance_transform_features(image,mask,coords),
+                lambda image,mask,coords: color_features(image,mask,coords),
+                lambda image,mask,coords: texture_features(image,mask,coords),
+                lambda image,mask,coords: morphological_features(image,mask,coords)
+        ],
+        preprocess = None,
+        sub_mask = lambda image,mask: stain_mask(image,mask),
+        mask_names = ['Nuclei','Eosinophilic','Luminal Space'],
+        channel_names = ['Red','Green','Blue'],
+        n_jobs = 4,
+        verbose = True
+    )
+    # Execute feature extraction
+    feature_df = feature_extractor.start(spot_annotations['features'])
+
+
+
+
+    # %%
+    # Add properties to spot annotations
+    spot_features = feature_df.to_dict('records')
+    for f,s in zip(spot_features,spot_annotations['features']):
+        s['properties'] = s['properties'] | {"Pathomics": f}
+
+    print(json.dumps(spot_annotations['features'][0]['properties'],indent=4))
+
+# %% [markdown]
+# ## Merging adjacent spots from the same cluster
+
+# %%
+# Merging adjacent spots based on Seurat cluster
+poly_list = []
+for f in spot_annotations['features']:
+    poly_list.append(Point(shape(f['geometry']).centroid))
+
+# Making the tissue mask
+def find_tissue(slide_tile_source):
+
+    # Grabbing the thumbnail of the image (RGB)
+    slide_metadata = slide_tile_source.getMetadata()
+    thumbnail_img,_ = slide_tile_source.getThumbnail()
+    thumb_array = np.array(Image.open(BytesIO(thumbnail_img)))
+
+    # Getting scale factors for thumbnail image to full-size image
+    thumbX, thumbY = np.shape(thumb_array)[1],np.shape(thumb_array)[0]
+    scale_x = slide_metadata['sizeX']/thumbX
+    scale_y = slide_metadata['sizeY']/thumbY
+
+    # Mean of all channels/frames to make grayscale mask
+    gray_mask = np.squeeze(np.mean(thumb_array,axis=-1))
+
+    threshold_val = 1.15*threshold_otsu(gray_mask)
+    tissue_mask = gray_mask <= threshold_val
+
+    tissue_mask = remove_small_holes(tissue_mask,area_threshold=150)
+    tissue_mask = remove_small_objects(tissue_mask,min_size=64)
+
+    #plt.imshow(tissue_mask)
+    #plt.show()
+    labeled_mask = label(tissue_mask)
+    tissue_pieces = np.unique(labeled_mask).tolist()
+    tissue_areas = [np.sum(labeled_mask==j) for j in tissue_pieces[1:]]
+    largest_2 = [tissue_pieces[1:][tissue_areas.index(m)] for m in tissue_areas if m in sorted(tissue_areas)[-2:]]
+
+    tissue_shape_list = []
+    for piece in largest_2:
+        if np.sum(labeled_mask==piece)>100:
+            tissue_contours = find_contours(labeled_mask==piece)
+            for contour in tissue_contours:
+                poly_list = [(i[1]*scale_x,i[0]*scale_y) for i in contour]
+                if len(poly_list)>2:
+                    obj_polygon = Polygon(poly_list)
+                    if obj_polygon.is_valid:
+                        tissue_shape_list.append(obj_polygon)
+
+    # Merging shapes together to remove holes
+    merged_tissue = unary_union(tissue_shape_list)
+    if merged_tissue.geom_type=='Polygon':
+        merged_tissue = [merged_tissue]
+    elif merged_tissue.geom_type in ['MultiPolygon','GeometryCollection']:
+        merged_tissue = merged_tissue.geoms
+
+    thumbnail_geojson = {
+        'type': 'FeatureCollection',
+        'features': [
+            {
+                'type':'Feature',
+                'geometry': {
+                    'type': 'Polygon',
+                    'coordinates': [list(i.exterior.coords)]
+                },
+                'properties': {
+                    'name': 'Tissue Mask',
+                    '_id': uuid.uuid4().hex[:24],
+                    '_index': idx
+                }
+            }
+            for idx,i in enumerate(merged_tissue) if i.geom_type=='Polygon'
+        ],
+        'properties': {
+            'name': 'Tissue Mask',
+            '_id': uuid.uuid4().hex[:24]
+        }
+    }
+
+    return thumbnail_geojson
+
+
+tissue_mask = find_tissue(
+    large_image.open('..\\..\\Test Upload\\new Visium\\V12U21-010_XY02_21-0069.tif')
+)
+
+unique_clusters = np.unique(clusters).tolist()
+merged_geojson = []
+for c in unique_clusters:
+    c_idx = np.where(clusters==c)[0].tolist()
+
+    cluster_spots = [poly_list[i] for i in c_idx]
+    cluster_merges = {
+        'type': 'FeatureCollection',
+        'features': [],
+        'properties': {
+            'name': f'Cluster {c}',
+            '_id': uuid.uuid4().hex[:24]
+        }
+    }
+    for t in tissue_mask['features']:
+        tissue_shape = shape(t['geometry'])
+        within_tissue_spots = [i for i in cluster_spots if i.within(tissue_shape)]
+        if len(within_tissue_spots)>0:
+            # Buffering spots to a size that they start to intersect
+            # (for Visium spots this is a little easier to define since all of the spots are separated 
+            # by the same distance, for other structures this might have to be some kind of Voronoi diagram)
+            buffered_spots = [i.buffer(100) for i in within_tissue_spots]
+
+            # Merging buffered spots
+            merged_spots = unary_union(buffered_spots)
+            cluster_geojson = [
+                {
+                    'type': 'Feature',
+                    'geometry': {
+                        'type': 'Polygon',
+                        'coordinates': [list(g.exterior.coords)]
+                    },
+                    'properties': {
+                        'name': f'Cluster {c}',
+                        '_id': uuid.uuid4().hex[:24],
+                        '_index': g_idx
+                    }
+                }
+                for g_idx,g in enumerate(merged_spots.geoms)
+            ]
+
+            cluster_merges['features'].extend(cluster_geojson)
+            
+    merged_geojson.append(cluster_merges)
+
+spatially_agged = []
+for m in merged_geojson:
+    spatially_agged.append(spatially_aggregate(m,[spot_annotations]))
+
+
+# %% [markdown]
+# ## Visualization in *fusion-tools*
+
+# %%
+# Visualizing spots in fusion-tools
+from fusion_tools.components import SlideMap,OverlayOptions,PropertyPlotter,HRAViewer, BulkLabels
+from fusion_tools import Visualization
+
+local_image_path = "..\\..\\Test Upload\\new Visium\\V12U21-010_XY02_21-0069.tif"
+
+vis_session = Visualization(
+    local_slides = [local_image_path],
+    local_annotations = [spot_annotations],
+    components = [
+        [
+            SlideMap(),
+            [
+                OverlayOptions(),
+                PropertyPlotter(),
+                #BulkLabels(),
+                HRAViewer()
+            ]
+        ]
+    ],
+    app_options = {
+        'jupyter': False,
+        'port': 8080
+    }
+)
+
+vis_session.start()
+
+
+