nettracer3d 1.2.5__py3-none-any.whl → 1.3.1__py3-none-any.whl

nettracer3d/tutorial.py

@@ -1098,8 +1098,6 @@ def setup_start_tutorial(window):
         )
 
 
-
-    
     
     # Step 9: Close dialog and finish
     def close_dialog():
@@ -1111,7 +1109,6 @@ def setup_start_tutorial(window):
         None,
         "That's it for the Intro tutorial! Select the Basic Interface Tour next to see how to use the main GUI elements.",
         message_position="bottom",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'properties_dialog', 'xy_scale', 'close()'),
         action=close_dialog
     )
 
@@ -1631,48 +1628,60 @@ def setup_connectivity_tutorial(window):
     )
 
     tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'inners'),
-        "Deselecting this button will have the system not consider 'inner edges'. Inner edges are portions of your edge image that exist solely within nodes (as well as their expanded search regions). You can deselect this to ignore inner connections between within node clusters, for example if you only wanted to consider more distal connections to get a simpler network. However, I would recommend keeping this enabled unless you had a good reason to not.",
+        MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'voronoi_safe'),
+        "The next few options present alternate ways to handle the trunk/edges if desired. Selecting this 'Auto-Trunk' method will make edge elements that exist as plexuses between nodes simplify themselves to make local connections but avoid more distant connections that have more local connectivity available. This is done by first computing the normal network, then computing a second network where the search regions are fully maxed out (and therefore naturally split trunks up; note, this step will not use parallel dilation), then pruning the second network to drop connections that don't exist in the first region. As such, it will be somewhat slower if enabled.",
         highlight_type=None,
         message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'inners', 'click()'))
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'voronoi_safe', 'click()'),
+        action = MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'voronoi_safe', 'toggle()')
+    )
 
     tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'down_factor'),
-        "Enter an int here to downsample your nodes prior to finding their centroids. The resultant centroids will be scaled back up to their proper values. This can speed up the centroid calculation and is recommended for large images. Note that small nodes may be completely erased if the downsample is too large. A larger int equates to a greater downsample. Downsampling here will also enlarge any overlays generated in this window.",
+        MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'labeled_branches'),
+        "The 'Convert Edges to Nodes' option will make your edges become nodes. This can be a good way to visualize direct connectivity paths, and is a robust way to mitigate bias in what is or isn't a trunk. However, the network dynamics will be altered by edge inclusion, resulting in much less node clusters in favor of edge-derived hubs.",
         highlight_type=None,
         message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'down_factor', 'setText("INTEGER!")'),
-        action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'down_factor', 'setText("")')
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'labeled_branches', 'click()'),
+        action = MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'labeled_branches', 'toggle()')
     )
 
-    """ # <-- so I am trying out removing these because their use cases are confusing
-
     tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'GPU_downsample'),
-        "If you want to try and use the GPU, you can likewise enter an arbitrary integer downsample factor here to speed it up. Note the GPU calculation can be greedy with VRAM and will automatically try to downsample itself in a lot of cases."
+        MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'edge_node'),
+        "The 'Pre-labeled edges' option will allow you to use pre-made edge labels, such as if you had previously labeled the branches of your edges. Instead of just joining nodes together, all edge labels will participate as nodes as well. This can be a way to visualize how branch-like structures in your edges interact with your main node objects. You can also do this from the modify network after the calculation has been done.",
         highlight_type=None,
         message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'GPU_downsample', 'setText("INTEGER!")'),
-        action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'GPU_downsample', 'setText("")')
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'edge_node', 'click()'),
+        action = MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'edge_node', 'toggle()')
     )
 
+
+
+    """
+
     tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'GPU'),
-        "Enable this to have your system attempt to use the GPU. You will need a CUDA toolkit and a corresponding cupy package installed. Note that I consider this function somewhat experimental. In short, the cupy implementation uses a distance transform calculation that can be very greedy with VRAM. If it overflows, it will attempt to iteratively downsample itself until the calculation works (specifically containing to calculating the 'node search' volume). Note this risks kicking out small nodes from your image. Furthermore, it is only really applicable of 'fast dilation' is enabled. Therefore, generally skip using this option. However, it can be a way to rapidly assess the general network structure of a large image.",
+        MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'inners'),
+        "Deselecting this button will have the system not consider 'inner edges'. Inner edges are portions of your edge image that exist solely within nodes (as well as their expanded search regions). You can deselect this to ignore inner connections between within node clusters, for example if you only wanted to consider more distal connections to get a simpler network. However, I would recommend keeping this enabled unless you had a good reason to not.",
         highlight_type=None,
         message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'GPU', 'click()'),
-        action = MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'GPU', 'toggle()'))
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'inners', 'click()'))
+    """
 
     tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'fastdil'),
-        "Enable this to have the algorithm use fast dilation. Fast dilation "
+        MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'down_factor'),
+        "Enter an int here to downsample your nodes prior to finding their centroids. The resultant centroids will be scaled back up to their proper values. This can speed up the centroid calculation and is recommended for large images. Note that small nodes may be completely erased if the downsample is too large. A larger int equates to a greater downsample. Downsampling here will also enlarge any overlays generated in this window.",
         highlight_type=None,
         message_position="beside",
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'down_factor', 'setText("INTEGER!")'),
+        action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'down_factor', 'setText("")')
+    )
+
+    tutorial.add_step(
+        MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'fastdil'),
+        "Enable the fast search button to use a slightly alternate algorithm for the node search step that is faster. This algorithm uses a parallelized distance transform to create a binary search region which is a lot faster if you have a lot of CPU cores. It then uses flooding to label the binary search region, which leads to slightly rough labeling where two search regions meet. When disabled, a non-parallel distance transform is used, which can be slower but always has exact labels where two search regions meet. I recommend enabling this for larger images and disabling it for smaller ones.",        highlight_type=None,
+        message_position="beside",
         pre_action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'fastdil', 'click()'),
-        action = MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'fastdil', 'toggle()'))
-    """
+        action=MenuHelper.create_widget_interaction(tutorial, 'con_dialog', 'fastdil', 'toggle()')
+    )
 
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'con_dialog', 'overlays'),
@@ -1765,47 +1774,19 @@ def setup_branch_tutorial(window):
         pre_action=open_dialog
     )
 
-    """
-    tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'fix'),
-        "This first auto-correction option is designed if you feel like the branch labels are generally too busy. Selecting this will have the program attempt to collapse overly-dense regions of branches into a single label. Note that this behavior is somewhat tricky to predict so I generally don't use it but feel free to give it a shot and see how it looks.",
-        highlight_type=None,
-        message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix', 'click()'),
-        action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix', 'toggle()')
-    )
-    
-    tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'fix_val'),
-        "This integer value tells the above parameter (if enabled) what degree of branch-busyness should get merged. In short, a lower value is more aggressive with merging while a higher value only merges very busy regions. By default it is set to 4.",
-        highlight_type=None,
-        message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix_val', 'selectAll()'),
-        action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix_val', 'deselect()')
-    )
-
-    tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'seed'),
-        "The random seed for grouping branches above can be changed here with an integer value, if the behavior of the above option is desired to be tweaked somewhat. It will use 42 by default.",
-        highlight_type=None,
-        message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'seed', 'setText("INTEGER!")'),
-        action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'seed', 'setText("")')
-    )
-
-    """
 
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'fix2'),
-        "The second auto-correction option will automatically merge any internal labels that arise with their outer-neighbors. This is something that can occasionally happen with fat, trunk-like branches that are tricky to algorithmically decipher. I have found that this merge handles these issues quite well, so this option is enabled by default.",
+        "The first auto-correction option will automatically merge any internal labels that arise with their outer-neighbors. This is something that can occasionally happen with fat, trunk-like branches that are tricky to algorithmically decipher. I have found that this merge handles these issues quite well, so this option is enabled by default. An alternate option will make the internal labels only merge with external structures that are not 'branch-like'. This is a good thing to enable if you are also enabling the 'reunify main branches' correction, as it will stop long branches from merging with core-like elements.",
         highlight_type=None,
         message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix2', 'click()')
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix2', 'showPopup()'),
+        action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix2', 'hidePopup()')
     )
 
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'fix3'),
-        "This auto-correction step will automatically correct any branches that aren't contiguous in space. Rarely (Depending on the segmentation, really) a branch can initially be labeled non-contiguously, which is usually not correct. This is because the 'meat' of any branch is at first labeled based on which internal filament it's closest to. So if you have a very wide branch it may rarely aquire labels of nearby smaller branches across gaps. Enabling this will split those labels into seperate regions as to not confound the connectivity graph. The largest component is considered the 'correct one' and keeps its label, while smaller components inherit the label of the largest shared border of a 'real' branch they are bordering. It is enabled here by default to mitigate any potential errors, although note this does not apply to the branchpoint networks since they don't actually utilize the branches themselves.",
+        "The second auto-correction step will automatically correct any branches that aren't contiguous in space. Rarely (Depending on the segmentation, really) a branch can initially be labeled non-contiguously, which is usually not correct. This is because the 'meat' of any branch is at first labeled based on which internal filament it's closest to. So if you have a very wide branch it may rarely aquire labels of nearby smaller branches across gaps. Enabling this will split those labels into seperate regions as to not confound the connectivity graph. The largest component is considered the 'correct one' and keeps its label, while smaller components inherit the label of the largest shared border of a 'real' branch they are bordering. It is enabled here by default to mitigate any potential errors, although note this does not apply to the branchpoint networks since they don't actually utilize the branches themselves.",
         highlight_type=None,
         message_position="beside",
         pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix3', 'click()')
@@ -1838,6 +1819,15 @@ def setup_branch_tutorial(window):
         action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'down_factor', 'deselect()')
     )
 
+    tutorial.add_step(
+        MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'mode'),
+        "The Algorithm Dropdown lets you choose between the standard algorithm, which provides more exact labels along branch borders, and the faster labeling algorithm, which uses flooding to label the binary branches, leading to slightly rough labeling where two branches meet. I recommend using the standard for smaller images and the fast for larger images where computation time becomes an issue.",
+        highlight_type=None,
+        message_position="beside",
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'mode', 'showPopup()'),
+        action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'mode', 'hidePopup()')
+    )
+
 
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'compute'),
@@ -1881,16 +1871,6 @@ def setup_branch_tutorial(window):
         pre_action=open_dialog
     )
 
-    tutorial.add_step(
-        MenuHelper.create_widget_getter(tutorial, 'gen_dialog', 'down_factor'),
-        "This integer value can be used to temporarily downsample the image while creating branchpoints. Aside from speeding up the process, this may alter branch detection, possibly performing a cleaner branch appraisal of very thick branches but losing network identification of smaller branches (Much like in the prior menu - note that any value entered in the prior menu will be applied by default here for consistency, and you won't see this option). It is disabled by default. Larger values will downsample more aggressively.",
-        highlight_type=None,
-        message_position="beside",
-        pre_action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'down_factor', 'selectAll()'),
-        action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'down_factor', 'deselect()')
-    )
-
-
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'gen_dialog', 'branch_removal'),
         "IMPORTANT - This branch removal parameter (Skeleton voxel branch to remove...) is something I would consider entering a value for. This is the length of terminal branches that will be removed prior to any vertex/branch labeling. Any branch shorter than the value here will be removed, but only if it is a terminal branch. For more jagged segmentations, this may be a necessity to prevent branchpoints from arising from spine-like artifacts. More internal branches will not be removed, so as a test it is generally safe to enter a large value here, which will preserve the majority of the branch schema and just risk losing occasional terminal branches.",
@@ -1900,6 +1880,7 @@ def setup_branch_tutorial(window):
         action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'branch_removal', 'setText("")')
     )
 
+    """
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'gen_dialog', 'auto'),
         "This 'attempt to auto correct skeleton looping' option should generally be enabled for 3D data. In short it applies an extra algorithmic step to improve the branch detection algorithm. However, this does not really apply to 2D data. It will be enabled by default for 3D data and disabled by default for 2D data.",
@@ -1908,6 +1889,7 @@ def setup_branch_tutorial(window):
         pre_action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'auto', 'click()'),
         action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'auto', 'toggle()')
     )
+    """
 
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'gen_dialog', 'comp_dil'),
@@ -1918,6 +1900,26 @@ def setup_branch_tutorial(window):
         action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'comp_dil', 'setText("")')
     )
 
+    tutorial.add_step(
+        MenuHelper.create_widget_getter(tutorial, 'gen_dialog', 'fast_dil'),
+        "Enable fast dilation to use a parallelized distance transform to do 3D dilation which is a lot faster if you have a lot of CPU cores. Note that this only applies if you have chosen to merge your nodes.",        
+        highlight_type=None,
+        message_position="beside",
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'fast_dil', 'click()'),
+        action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'fast_dil', 'toggle()')
+    )
+
+    tutorial.add_step(
+        MenuHelper.create_widget_getter(tutorial, 'gen_dialog', 'down_factor'),
+        "This integer value can be used to temporarily downsample the image while creating branchpoints. Aside from speeding up the process, this may alter branch detection, possibly performing a cleaner branch appraisal of very thick branches but losing network identification of smaller branches (Much like in the prior menu - note that any value entered in the prior menu will be applied by default here for consistency, and you won't see this option). It is disabled by default. Larger values will downsample more aggressively.",
+        highlight_type=None,
+        message_position="beside",
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'down_factor', 'selectAll()'),
+        action=MenuHelper.create_widget_interaction(tutorial, 'gen_dialog', 'down_factor', 'deselect()')
+    )
+
+
+
     def close_dialog():
         if hasattr(tutorial, 'gen_dialog') and tutorial.gen_dialog:
             tutorial.gen_dialog.close()

{nettracer3d-1.2.5.dist-info → nettracer3d-1.3.1.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.2.5
+Version: 1.3.1
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <liamm@wustl.edu>
 Project-URL: Documentation, https://nettracer3d.readthedocs.io/en/latest/
-Project-URL: Reference_Citation_For_Use, https://doi.org/10.1101/2024.07.29.605633
+Project-URL: Youtube_Tutorial, https://www.youtube.com/watch?v=_4uDy0mzG94&list=PLsrhxiimzKJMZ3_gTWkfrcAdJQQobUhj7
+Project-URL: Downloadable_Version, https://doi.org/10.5281/zenodo.17873800
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
@@ -23,8 +24,8 @@ Requires-Dist: pandas
 Requires-Dist: tifffile
 Requires-Dist: qtrangeslider
 Requires-Dist: PyQt6
+Requires-Dist: pyqtgraph
 Requires-Dist: scikit-learn
-Requires-Dist: nibabel
 Requires-Dist: setuptools
 Requires-Dist: umap-learn
 Provides-Extra: cuda11
@@ -37,34 +38,78 @@ Provides-Extra: cellpose
 Requires-Dist: cellpose[GUI]; extra == "cellpose"
 Provides-Extra: viz
 Requires-Dist: napari; extra == "viz"
+Provides-Extra: rec
+Requires-Dist: napari; extra == "rec"
+Requires-Dist: edt; extra == "rec"
+Provides-Extra: edt
+Requires-Dist: edt; extra == "edt"
 Provides-Extra: all
 Requires-Dist: cellpose[GUI]; extra == "all"
 Requires-Dist: napari; extra == "all"
+Requires-Dist: edt; extra == "all"
 Dynamic: license-file
 
 NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity and volumetric thresholding, or random forest machine learning segmentation. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, enter the command 'nettracer3d' in your command prompt:
 
+
 --- Documentation ---
 
 Please see: https://nettracer3d.readthedocs.io/en/latest/
 
---- Installation ---
 
-To install nettracer3d, simply install Python. Make sure the Python installation installs pip, and that both Python and pip are available on your PATH. Next, use this command in your command terminal:
+--- Video Tutorial ---
+
+Please see: https://www.youtube.com/watch?v=_4uDy0mzG94&list=PLsrhxiimzKJMZ3_gTWkfrcAdJQQobUhj7
+
+
+--- Installing as a Python package ---
+
+1. **Get Python and Pip on your path**: To install nettracer3d, first install Python version 3.12. Make sure the Python installation installs pip, and that both Python and pip are available on your PATH. I recommend installing Python using the installer which is available here. Make sure to check the option to 'add Python to PATH' when it appears: https://www.python.org/downloads/
+
+
+2. **Base Package**: Next, use this command in your command terminal
+
+	* pip install nettracer3d
+
+
+3. **For 3D Displays**: Or if you also want Napari for 3D displays:
+
+	* pip install nettracer3d[viz]
+
+
+4. **Optional Performance Boost**: If you are trying to process large images, you may also want to include the 'edt' module in your package. This will allow parallelized CPU calculations for several of the search functions which can increase their speed by an order of magnitude or more depending on how many cores your CPU has. This can be a major benefit if you have a strong CPU and sufficient RAM. It requires an extra pre-installation step, thus is not included by default. You will also have to install the C++ build tools from windows. Please head to this link, then download and run the installer: https://visualstudio.microsoft.com/visual-cpp-build-tools/. In the menu of the installer, select the 'Desktop Development with C++' option, then proceed to download/install it using the installation menu. You will likely want to be using the Python distributed from the actual Python website and not the windows store (or elsewhere) or the edt module may not work properly. To bundle with edt use:
 
-pip install nettracer3d
+	* pip install nettracer3d[edt]
+
+
+5. **Recommended full package**: Or if you want to just get both edt and napari at once:
+	
+	* pip install nettracer3d[rec]
+
+
+6. Likewise, if you already installed the default version, you can add napari and/or edt with just:
+
+	* pip install edt
+	* pip install napari
+
+   
+--- Installing as a Python package in Anaconda---
 
 I recommend installing the program as an Anaconda package to ensure its modules are work together on your specific system:
 (Install anaconda at the link below, set up a new python env for nettracer3d, then use the same pip command).
 
 https://www.anaconda.com/download?utm_source=anacondadocs&utm_medium=documentation&utm_campaign=download&utm_content=installwindows
 
-Alternatively, you can download a compiled .exe of version 1.2.4 here: https://doi.org/10.5281/zenodo.17873800 
 
-Unzip the folder, then double click the NetTracer3D executable to run the program. Note that this version will be missing a few features compared to the Python package, namely the 3D display and the ability to print updates to the command window. It will also not be updated as often.
+--- Using the downloadable version ---
+
+Alternatively, you can download a compiled .exe of version 1.2.7 here: https://doi.org/10.5281/zenodo.17873800 
+
+Unzip the folder, then double click the NetTracer3D executable to run the program. Note that this version will be missing a few features compared to the Python package, namely GPU segmentation support and the ability to print updates to the command window. It will also not be updated as often.
+
+
+--- Optional Packages ---
 
-Optional Packages
-~~~~~~~~~~~~~~~~~~
 I recommend including Napari (Chi-Li Chiu, Nathan Clack, the napari community, napari: a Python Multi-Dimensional Image Viewer Platform for the Research Community, Microscopy and Microanalysis, Volume 28, Issue S1, 1 August 2022, Pages 1576–1577, https://doi.org/10.1017/S1431927622006328) in the download as well, which allows NetTracer3D to use 3D displays. The standard package only comes with its native 2D slice display window. 
 If Napari is present, all 3D images and overlays from NetTracer3D can be easily displayed in 3D with a click of a button. To package with Napari, use this install command instead: 
 
@@ -77,13 +122,13 @@ To include Cellpose3 in the install, use this command:
 
     pip install nettracer3d[cellpose]
 
-Alternatively, both Napari and Cellpose can be included in the package with this command: (Or they can be independently installed with pip from the base package env)
+Alternatively, Napari, Cellpose, and edt can be included in the package with this command: (Or they can be independently installed with pip from the base package env)
 
 
     pip install nettracer3d[all]
 
-GPU
-~~~~~~~~~~~~~~~~~~
+
+--- GPU ---
 NetTracer3D is mostly CPU-bound, but a few functions can optionally use the GPU. To install optional GPU functionalities, first set up a CUDA toolkit that runs with the GPU on your machine. This requires an NVIDIA GPU. Then, find your GPUs compatible CUDA toolkit and install it with the auto-installer from the NVIDIA website: https://developer.nvidia.com/cuda-toolkit
 
 With a CUDA toolkit installed, use:
@@ -110,8 +155,9 @@ NetTracer3D is freely available for academic and nonprofit use and can obtained
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 1.2.5 Updates --
+-- Version 1.3.1 Updates --
 
-	* Updated readme, license
-	
+	* Updated GUI to use pyqtgraph for image display rather than matplotlib
+	* Upgraded the network graph visualization to also use pyqtgraph rather than matplotlib - now renders much faster, is embedded in the main window, and interacts with the main image view display.
+	* Other minor tweaks and bug fixes
 	

nettracer3d-1.3.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nettracer3d/branch_stitcher.py,sha256=rCTeh-28o7yN6ghYwxVSfrn2oc-TiPOm1xB3xJ5RWbw,21216
+nettracer3d/cellpose_manager.py,sha256=NfRqW6Zl7yRU4qHCS_KjmR0R6QANSSgCO0_dr-eivxg,6694
+nettracer3d/community_extractor.py,sha256=rPXXWwMX05mfD_ogULEouLy8CST-aOaoSw45NhloKVg,31754
+nettracer3d/excelotron.py,sha256=aNof6k-DgMxVyFgsl3ltSCxG4vZW49cuvCBzfzhYhUY,75072
+nettracer3d/filaments.py,sha256=liuhikdRoANUmYA_hiPUPtDV-lYtR8wKbgnUVk55Hgs,43952
+nettracer3d/modularity.py,sha256=HgaVQSVjgAX3LAfJeUL1ZZ3P3xGuALJpQHqtYrhgw5c,22762
+nettracer3d/morphology.py,sha256=eusirbmDFQD__tlhkwZbctd8N4AARXVU0IGowr7M8cA,23297
+nettracer3d/neighborhoods.py,sha256=Bje77gWzXRIYyXkDlnFQnbUALnIt8dheLXHVFQsAKuc,53156
+nettracer3d/nettracer.py,sha256=kvatS_orNSLUQXuDZ5zBluP-Yau8nyoIYYWEcZyMzrs,298024
+nettracer3d/nettracer_gui.py,sha256=SIGGetHwyRv8xJShVjwvabhEIgPWtHAOvcKZMleyPVM,732175
+nettracer3d/network_analysis.py,sha256=QYZrzZ0T6Ubifw4hctvpw-V2lATN5jV5QtIF_UpcSpU,46363
+nettracer3d/network_draw.py,sha256=1Dj6VSMtMZbMxmrA7bWGxaLChqvM17xnZo85EUgG2PM,14291
+nettracer3d/network_graph_widget.py,sha256=dVuTRGEdjVOOJ4-DBCtOwQe-QpO3FwXvVYhC-oT3Xpo,80989
+nettracer3d/node_draw.py,sha256=Md12OiBtEyQmF2W_enO4qrSPFTRfoV4sOCMeEEdTNz4,10488
+nettracer3d/painting.py,sha256=10XBjDqfOb1nTbGgIicOpoeIKRZZ4al2uFtrv-8MIBE,16760
+nettracer3d/proximity.py,sha256=xvJLt61nTsKMdpJ0aiwJsB5vPriO34KG0LQwDjyfhC8,41410
+nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
+nettracer3d/segmenter.py,sha256=20ch_uLqedV9srwT1eL5eFs88ojkb2gELWJKgtYk2qk,72791
+nettracer3d/segmenter_GPU.py,sha256=FwzevixleTUoRmwVa8jPPzW82RZoC6nL2eEeZ4-2ZR8,80015
+nettracer3d/simple_network.py,sha256=1InpqSXfae_L-6lmf8lXgV7n_rk7Porg1hc_in9vkHg,10499
+nettracer3d/smart_dilate.py,sha256=1UzLnX5LCj6OuFIy7_gHcZe9OIHkVJdIkZJDuJNqyYc,32009
+nettracer3d/stats.py,sha256=0YwrVLeEvll3PlbL5-0_9dstldr48PvxJrQm-PiC8jY,36607
+nettracer3d/tutorial.py,sha256=48__h2pWuERJLxC08_khFRW4XVf5vSXZtWnNUAFyWDY,154591
+nettracer3d-1.3.1.dist-info/licenses/LICENSE,sha256=_Wg4zyCtT18lXBCXRov17IEop_-7z1OFo6o3JTzQj3g,568
+nettracer3d-1.3.1.dist-info/METADATA,sha256=SVbWu_ycx1tghOiGVAA8w3EwlvVsnCKTGae6R9Io-RM,9676
+nettracer3d-1.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nettracer3d-1.3.1.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-1.3.1.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-1.3.1.dist-info/RECORD,,

nettracer3d-1.2.5.dist-info/RECORD

@@ -1,29 +0,0 @@
-nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nettracer3d/branch_stitcher.py,sha256=gyDVPUnApS2jmlIglJoRVEVY8WXLqwpr0_8rNdvy9u0,16402
-nettracer3d/cellpose_manager.py,sha256=NfRqW6Zl7yRU4qHCS_KjmR0R6QANSSgCO0_dr-eivxg,6694
-nettracer3d/community_extractor.py,sha256=rPXXWwMX05mfD_ogULEouLy8CST-aOaoSw45NhloKVg,31754
-nettracer3d/excelotron.py,sha256=aNof6k-DgMxVyFgsl3ltSCxG4vZW49cuvCBzfzhYhUY,75072
-nettracer3d/filaments.py,sha256=ks3-ThdHRKu5hPk04R_YHAmVpwCqXraR0LWW0VRlAts,43693
-nettracer3d/modularity.py,sha256=pborVcDBvICB2-g8lNoSVZbIReIBlfeBmjFbPYmtq7Y,22443
-nettracer3d/morphology.py,sha256=QlBPsJAswBoinjZuouNwEfGEGwclvenlZ1Vmo288QLo,23287
-nettracer3d/neighborhoods.py,sha256=Bje77gWzXRIYyXkDlnFQnbUALnIt8dheLXHVFQsAKuc,53156
-nettracer3d/nettracer.py,sha256=9iQ51fvYUNsHA90lZd4cEVz_4AZZToTy22SjJoZNPHY,294254
-nettracer3d/nettracer_gui.py,sha256=oStQZCqzi_nDFq8NKjMA1n0cuMv77gKekOd6XQFO5H4,742021
-nettracer3d/network_analysis.py,sha256=kBzsVaq4dZkMe0k-VGvQIUvM-tK0ZZ8bvb-wtsugZRQ,46150
-nettracer3d/network_draw.py,sha256=Uw0w1MoFiYMirkdM_XDAfy_m5_MoVaZkkGpoYzN9_-c,14259
-nettracer3d/node_draw.py,sha256=LeSftKJiNGkC7cpBJuf8Y9JeTUaUjcD6I2byclmZCb4,10484
-nettracer3d/painting.py,sha256=K_dwngivw80r-Yyg4btKMsWGn566ZE9PnrQl986uxJE,23497
-nettracer3d/proximity.py,sha256=Q3FxRpihV4ck7SUKrmceBRK1P32xZiLNzbUcr4PpnBM,46717
-nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
-nettracer3d/segmenter.py,sha256=20ch_uLqedV9srwT1eL5eFs88ojkb2gELWJKgtYk2qk,72791
-nettracer3d/segmenter_GPU.py,sha256=FwzevixleTUoRmwVa8jPPzW82RZoC6nL2eEeZ4-2ZR8,80015
-nettracer3d/simple_network.py,sha256=dkG4jpc4zzdeuoaQobgGfL3PNo6N8dGKQ5hEEubFIvA,9947
-nettracer3d/smart_dilate.py,sha256=gtL7hxzae93PJQsGLnUrwQ6Wb0evnHHREh0rHyUh_48,28644
-nettracer3d/stats.py,sha256=0YwrVLeEvll3PlbL5-0_9dstldr48PvxJrQm-PiC8jY,36607
-nettracer3d/tutorial.py,sha256=cUxiBf5RaBTtr9uJ2qoxZjRkcAY8mrvS9_LEqiwoxLc,153564
-nettracer3d-1.2.5.dist-info/licenses/LICENSE,sha256=_Wg4zyCtT18lXBCXRov17IEop_-7z1OFo6o3JTzQj3g,568
-nettracer3d-1.2.5.dist-info/METADATA,sha256=KGky4Y1X3pHgoykGd-SaJkp6x4faTeH6K-uh2r7wvL0,7164
-nettracer3d-1.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nettracer3d-1.2.5.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-1.2.5.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-1.2.5.dist-info/RECORD,,