fusion-tools 2.2.3__tar.gz → 2.2.5__tar.gz

{fusion_tools-2.2.3 → fusion_tools-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fusion-tools
-Version: 2.2.3
+Version: 2.2.5
 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.2.3 → fusion_tools-2.2.5}/setup.py

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

{fusion_tools-2.2.3 → fusion_tools-2.2.5}/src/fusion_tools/components/maps.py

@@ -314,7 +314,7 @@ class SlideMap(MapComponent):
         
         """
         self.js_namespace = Namespace(
-            "fusionTools","default"
+            "fusionTools","slideMap"
         )
 
         self.js_namespace.add(
@@ -1346,8 +1346,6 @@ class MultiFrameSlideMap(SlideMap):
                 else:
                     frame_names = [f'Frame {i}' for i in range(len(image_metadata['frames']))]
 
-                print(frame_names)
-                print(len(image_metadata['frames']))
                 # This is a multi-frame image
                 if len(image_metadata['frames'])==3:
                     # Treat this as an RGB image by default

{fusion_tools-2.2.3 → fusion_tools-2.2.5}/src/fusion_tools/components/segmentation.py

@@ -23,10 +23,11 @@ from skimage.measure import label
 import dash
 dash._dash_renderer._set_react_version('18.2.0')
 import dash_leaflet as dl
-from dash import dcc, callback, ctx, ALL, MATCH, exceptions, Patch, no_update, dash_table
+from dash import dcc, callback, ctx, ALL, MATCH, exceptions, Patch, no_update, dash_table, ClientsideFunction
 import dash_bootstrap_components as dbc
 import dash_mantine_components as dmc
 from dash_extensions.enrich import DashBlueprint, html, Input, Output, State, PrefixIdTransform, MultiplexerTransform
+from dash_extensions.javascript import Namespace
 
 # fusion-tools imports
 from fusion_tools.visualization.vis_utils import get_pattern_matching_value
@@ -917,6 +918,9 @@ class BulkLabels(Tool):
         self.ignore_list = ignore_list
         self.property_depth = property_depth
 
+        self.assets_folder = os.getcwd()+'/.fusion_assets/'
+        self.get_namespace()
+
     def __str__(self):
         return 'Bulk Labels'
 
@@ -954,6 +958,112 @@ class BulkLabels(Tool):
 
         return x_scale, y_scale
 
+    def get_namespace(self):
+        """Adding JavaScript functions to the BulkLabels Namespace
+        """
+        self.js_namespace = Namespace(
+            "fusionTools","bulkLabels"
+        )
+
+        self.js_namespace.add(
+            name = "propertyFilter",
+            src = """
+                function(butt_click, structure_names, filter_json, map_annotations, slide_information) {
+                    var returnFeature = true;
+                    // Defining function to extract property value
+                    function checkFilter(feature, filterItem) {
+                        if (filterItem.name) {
+                            var filterSubProps = filterItem.name.split(" --> ");
+                            var prop_dict = feature.properties;
+                            for (let i=0; i<filterSubProps.length; i++) {
+                                if (filterSubProps[j] in prop_dict) {
+                                    var prop_dict = prop_dict[filterSubProps[j]];
+                                    var testVal = prop_dict;
+                                } else {
+                                    var testVal = false;
+                                }
+                            }
+                            
+                            if (filterItem.range & testVal) {
+                                if (typeof filterItem.range[0]==='number') {
+                                    if (testVal < filterItem.range[0]) {
+                                        returnFeature = returnFeature & false;
+                                    }
+                                    if (testVal > filterItem.range[1]) {
+                                        returnFeature = returnFeature & false;
+                                    }
+                                } else {
+                                    if (filterItem.range.includes(testVal)) {
+                                        returnFeature = returnFeature & true;
+                                    } else {
+                                        returnFeature = returnFeature & false;
+                                    }
+                                }
+                            } else {
+                                returnFeature = returnFeature & false;
+                            }
+                        } 
+
+                        return returnFeature;
+                    }
+
+                    // Reading in filters dictionary
+                    const filters = JSON.parse(filter_json);
+                    console.log(filters);
+
+                    // Reading in annotations
+                    const annotations = JSON.parse(map_annotations);
+                    var namesList = [];
+                    for (let i = 0; i<annotations.length; i++) {
+                        namesList.push(annotations[i]["properties"]["name"]);
+                    }
+                    console.log(namesList);
+
+                    // Getting desired annotation for left joins
+                    var baseAnnotations = {
+                        "type": "FeatureCollection",
+                        "features": []
+                    };
+
+                    for (let i = 0; i<structure_names.length; i++) {
+                        baseAnnotations["features"].push(annotations[namesList.indexOf(structure_names[i])]);
+                    }
+
+                    // Performing filtration
+                    for (let j = 0; j < filters.length; j++) {
+                        // Checking if this is a spatial query
+                        if ("structure" in filters[j]) {
+                            var sqAnnotation = annotations[namesList.indexOf(filters[j]["structure"])];
+                            baseAnnotations.splice(i,1,sjoin(baseAnnotations[i],sqAnnotation, { how: "inner", op: filters[j]["type"] }));
+                        } else {
+                            for (let k = 0; k < baseAnnotations['features'].length; k++) {
+                                var check = checkFilter(baseAnnotations["features"], filters[j]);
+                                if (!check) {
+                                    baseAnnotations['features'].splice(k,1);
+                                }
+                            }
+                        }
+                    }
+                    console.log(baseAnnotations['features'].length);
+                    
+                    // Creating L.Marker() objects
+                    var marker_list = [];
+                    for (let j = 0; j < baseAnnotations['features'].length; j++) {
+                        var centroid = turf.centroid(turf.polygon(baseAnnotations['features'][j]['geometry']));
+
+                        marker_list.push(
+                            L.Marker(
+                                centroid
+                            ).bindPopup()
+                        );
+
+                    }   
+                }
+            """
+        )
+
+
+
     def gen_layout(self, session_data:dict):
         """Generating layout for BulkLabels component
 
@@ -1254,6 +1364,32 @@ class BulkLabels(Tool):
                 Output({'type': 'bulk-labels-apply-labels','index': ALL},'disabled'),
                 Output({'type': 'bulk-labels-download-labels','index': ALL},'disabled')
             ],
+            [
+                State({'type': 'bulk-labels-include-structures','index': ALL},'value'),
+                State({'type': 'bulk-labels-filter-data','index': ALL},'data'),
+                State({'type': 'map-annotations-store','index': ALL},'data'),
+                State({'type': 'map-slide-information','index': ALL},'data')
+            ]
+        )(self.update_label_structures)
+
+        self.blueprint.clinetside_callback(
+            ClientsideFunction(
+                namespace = 'fusionTools',
+                function_name = ''
+            ),
+            [
+                Input({'type': 'bulk-labels-update-structures','index': ALL},'n_clicks')
+            ],
+            [
+                Output({'type': 'bulk-labels-current-structures','index': ALL},'children'),
+                Output({'type': 'map-marker-div','index': ALL},'children'),
+                Output({'type': 'bulk-labels-label-source','index': ALL},'children'),
+                Output({'type': 'bulk-labels-label-type','index': ALL},'disabled'),
+                Output({'type': 'bulk-labels-label-text','index': ALL},'disabled'),
+                Output({'type': 'bulk-labels-label-rationale','index': ALL},'disabled'),
+                Output({'type': 'bulk-labels-apply-labels','index': ALL},'disabled'),
+                Output({'type': 'bulk-labels-download-labels','index': ALL},'disabled')
+            ],
             [
                 State({'type': 'bulk-labels-include-structures','index': ALL},'value'),
                 State({'type': 'bulk-labels-add-property-div','index': ALL},'children'),
@@ -1261,7 +1397,7 @@ class BulkLabels(Tool):
                 State({'type': 'map-annotations-store','index': ALL},'data'),
                 State({'type': 'map-slide-information','index': ALL},'data')
             ]
-        )(self.update_label_structures)
+        )
 
         # Adding new property
         self.blueprint.callback(
@@ -2097,9 +2233,10 @@ class BulkLabels(Tool):
         n_marked = len(get_pattern_matching_value(current_markers))
 
         patched_list = Patch()
-        values_to_remove = np.where(clear_click)[0].tolist()
-        for v in values_to_remove:
-            del patched_list[v]
+        for v_idx,v in enumerate(clear_click):
+            if v:
+                del patched_list[v_idx]
+                break
         
         new_structures_div = [
             dbc.Alert(

{fusion_tools-2.2.3 → fusion_tools-2.2.5}/src/fusion_tools/feature_extraction.py

@@ -156,7 +156,7 @@ class ParallelFeatureExtractor:
         width = int(bbox[2] - bbox[0])
 
         # polygon2mask expects y,x coordinates, scaled to within shape bounding box
-        scaled_coords = np.flip(np.squeeze(coords_array)-np.array([bbox[0], bbox[1], 0]),axis=1)
+        scaled_coords = np.flip(np.squeeze(coords_array)-np.array([bbox[0], bbox[1]]),axis=1)
         if np.shape(scaled_coords)[-1]==3:
             scaled_coords = scaled_coords[:,1:]
 

{fusion_tools-2.2.3 → fusion_tools-2.2.5}/src/fusion_tools/utils/shapes.py

@@ -67,33 +67,30 @@ def load_geojson(geojson_path: str, name:Union[str,None]=None) -> dict:
     with open(geojson_path,'r') as f:
         geojson_anns = json.load(f)
         f.close()
-    
-    print(type(geojson_anns))
-    print(len(geojson_anns))
 
     if type(geojson_anns)==list:
         for g in geojson_anns:
             if not 'properties' in g:
                 g['properties'] = {}
+            else:
+                if 'name' in g['properties'] and name is None:
+                    name = g['properties']['name']
 
             geo_id = uuid.uuid4().hex[:24] if not '_id' in g['properties'] else g['properties']['_id']
             g['properties'] = g['properties'] | {'name': name if not name is None else geo_id, '_id': geo_id}
 
-            
             for f_idx, f in enumerate(g['features']):
                 f['properties'] = f['properties'] | {'name': name if not name is None else geo_id, '_id': uuid.uuid4().hex[:24], '_index': f_idx}
 
     elif type(geojson_anns)==dict:
         if not 'properties' in geojson_anns:
             geojson_anns['properties'] = {}
-            geo_id = uuid.uuid4().hex[:24] if not '_id' in g['properties'] else geojson_anns['properties']['_id']
-            geojson_anns['properties'] = geojson_anns['properties'] | {'name': name if not name is None else geo_id, '_id': geo_id}
-
-            
-            for f_idx, f in enumerate(geojson_anns['features']):
-                f['properties'] = f['properties'] | {'name': name if not name is None else geo_id, '_id': uuid.uuid4().hex[:24], '_index': f_idx}
 
+        geo_id = uuid.uuid4().hex[:24] if not '_id' in g['properties'] else geojson_anns['properties']['_id']
+        geojson_anns['properties'] = geojson_anns['properties'] | {'name': name if not name is None else geo_id, '_id': geo_id}
 
+        for f_idx, f in enumerate(geojson_anns['features']):
+            f['properties'] = f['properties'] | {'name': name if not name is None else geo_id, '_id': uuid.uuid4().hex[:24], '_index': f_idx}
 
     return geojson_anns
 
@@ -1016,8 +1013,6 @@ def process_filters_queries(filter_list:list, spatial_list:list, structures:list
         structure_filtered = [gpd.GeoDataFrame.from_features(i['features']) for i in all_geo_list]
         name_order = [i['properties']['name'] for i in all_geo_list]
 
-    #all_names = [i['properties']['name'] for i in all_geo_list]
-
     # Now going through spatial queries
     filter_reference_list = {
         n: {}
@@ -1048,6 +1043,8 @@ def process_filters_queries(filter_list:list, spatial_list:list, structures:list
                     )
 
                 intermediate_gdf = intermediate_gdf.drop([i for i in ['index_left','index_right'] if i in intermediate_gdf], axis = 1)
+                intermediate_gdf = intermediate_gdf.drop([i for i in intermediate_gdf if '_right' in i],axis=1)
+                intermediate_gdf.columns = [i.replace('_left','') if '_left' in i else i for i in intermediate_gdf ]
 
             remainder_structures.append(intermediate_gdf)
     else:
@@ -1060,21 +1057,11 @@ def process_filters_queries(filter_list:list, spatial_list:list, structures:list
     }
     for g,name in zip(remainder_structures,name_order):
         g_json = g.to_geo_dict(show_bbox=True)
-        #feature_geos = [i['geometry'] for i in g_json['features']]
-
-
         filter_reference_list[name] = {
             i+len(combined_geojson['features']):j['properties']['_index']
             for i,j in enumerate(g_json['features'])
         }
         combined_geojson['features'].extend(g_json['features'])
-        """
-        if len(g_json['features'])>0:
-            for idx, i in enumerate(all_geo_list[all_names.index(name)]['features']):
-                if i['geometry'] in feature_geos:
-                    filter_reference_list[name][len(combined_geojson['features'])] = idx
-                    combined_geojson['features'].append(g_json['features'][feature_geos.index(i['geometry'])])
-        """
 
     # Going through property filters:
     if len(filter_list)>0:

{fusion_tools-2.2.3 → fusion_tools-2.2.5}/src/fusion_tools/visualization/components.py

@@ -29,15 +29,12 @@ class Visualization:
 
         components = [
             [
-                SlideMap(
-                    tile_server = LocalTileServer("/path/to/slide.svs"),
-                    annotations = geojson_list
-                )
+                SlideMap()
             ],
             [
                 [
-                    OverlayOptions(geojson_list),
-                    PropertyViewer(geojson_list)
+                    OverlayOptions(),
+                    PropertyViewer()
                 ]
             ]
         ]
@@ -95,7 +92,9 @@ class Visualization:
                 MultiplexerTransform()
             ],
             'external_scripts': [
-                'https://cdnjs.cloudflare.com/ajax/libs/chroma-js/2.1.0/chroma.min.js'
+                'https://cdnjs.cloudflare.com/ajax/libs/chroma-js/2.1.0/chroma.min.js',
+                'https://cdn.jsdelivr.net/npm/spatialmerge',
+                'https://cdn.jsdelivr.net/npm/@turf/turf@7/turf.min.js'
             ]
         }
 

{fusion_tools-2.2.3 → fusion_tools-2.2.5}/src/fusion_tools.egg-info/PKG-INFO

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