motile-tracker 0.0.1.dev0__py3-none-any.whl

installer_hooks/hook-OpenGL.py

@@ -0,0 +1,73 @@
+# ------------------------------------------------------------------
+# Copyright (c) 2020 PyInstaller Development Team.
+#
+# This file is distributed under the terms of the GNU General Public
+# License (version 2.0 or later).
+#
+# The full license is available in LICENSE.GPL.txt, distributed with
+# this software.
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+# ------------------------------------------------------------------
+
+
+"""
+Hook for PyOpenGL 3.x versions from 3.0.0b6 up. Previous versions have a
+plugin system based on pkg_resources which is problematic to handle correctly
+under pyinstaller; 2.x versions used to run fine without hooks, so this one
+shouldn't hurt.
+"""
+
+
+from PyInstaller.compat import is_win, is_darwin
+from PyInstaller.utils.hooks import collect_data_files, exec_statement
+import os
+import glob
+
+
+def opengl_arrays_modules():
+    """
+    Return list of array modules for OpenGL module.
+    e.g. 'OpenGL.arrays.vbo'
+    """
+    statement = 'import OpenGL; print(OpenGL.__path__[0])'
+    opengl_mod_path = exec_statement(statement)
+    arrays_mod_path = os.path.join(opengl_mod_path, 'arrays')
+    files = glob.glob(arrays_mod_path + '/*.py')
+    modules = []
+
+    for f in files:
+        mod = os.path.splitext(os.path.basename(f))[0]
+        # Skip __init__ module.
+        if mod == '__init__':
+            continue
+        modules.append('OpenGL.arrays.' + mod)
+
+    return modules
+
+
+# PlatformPlugin performs a conditional import based on os.name and
+# sys.platform. PyInstaller misses this so let's add it ourselves...
+if is_win:
+    hiddenimports = ['OpenGL.platform.win32']
+elif is_darwin:
+    hiddenimports = ['OpenGL.platform.darwin']
+# Use glx for other platforms (Linux, ...)
+else:
+    hiddenimports = ['OpenGL.platform.glx', 'OpenGL.platform.egl']
+
+
+# Arrays modules are needed too.
+hiddenimports += opengl_arrays_modules()
+
+
+# PyOpenGL 3.x uses ctypes to load DLL libraries. PyOpenGL windows installer
+# adds necessary dll files to 
+#   DLL_DIRECTORY = os.path.join( os.path.dirname( OpenGL.__file__ ), 'DLLS')
+# PyInstaller is not able to find these dlls. Just include them all as data
+# files.
+if is_win:
+    datas = collect_data_files('OpenGL')
+
+print("Loaded OpenGL!", hiddenimports)
+

installer_hooks/hook-fonticon_fa6.py

@@ -0,0 +1,8 @@
+from PyInstaller.utils.hooks import (collect_submodules,
+                                     collect_data_files)
+
+datas = collect_data_files('fonticon_fa6')
+
+hiddenimports = collect_submodules('fonticon_fa6')
+
+print("Loaded fonticon_fa6!", datas, hiddenimports)

installer_hooks/hook-freetype.py

@@ -0,0 +1,4 @@
+# Hook required for IPython autocomplete
+
+
+hiddenimports = ["freetype"]

installer_hooks/hook-ilpy.py

@@ -0,0 +1,5 @@
+from PyInstaller.utils.hooks import collect_all
+
+datas, binaries, hiddenimports = collect_all('ilpy.impl.solvers')
+
+print("Loaded ilpy!", datas, binaries, hiddenimports)

installer_hooks/hook-ipykernel.py

@@ -0,0 +1 @@
+hiddenimports = ["ipykernel.datapub"]

installer_hooks/hook-motile_tracker.py

@@ -0,0 +1,5 @@
+from PyInstaller.utils.hooks import collect_all
+
+datas, binaries, hiddenimports = collect_all('motile_tracker')
+
+print("Loaded motile_tracker!", datas, binaries, hiddenimports)

installer_hooks/hook-napari.py

@@ -0,0 +1,19 @@
+from PyInstaller.utils.hooks import collect_data_files, collect_submodules
+
+datas = collect_data_files('napari')
+datas += collect_data_files('napari_builtins')
+datas += collect_data_files('napari_svg')
+
+hiddenimports = collect_submodules("napari") 
+hiddenimports = collect_submodules("napari_svg") 
+
+hiddenimports += [
+    'napari.viewer',
+    'napari.plugins',
+    'napari._event_loop',
+    'napari.__main__',
+    'napari._qt',
+    'napari._qt.qt_main_window',
+    'napari_builtins',
+    'napari_plugin_manager',
+]

installer_hooks/hook-parso.py

@@ -0,0 +1,5 @@
+# Hook required for IPython autocomplete
+
+from PyInstaller.utils.hooks import collect_data_files
+
+datas = collect_data_files('parso')

installer_hooks/hook-superqt.py

@@ -0,0 +1,7 @@
+from PyInstaller.utils.hooks import collect_submodules
+
+hiddenimports = collect_submodules('superqt')
+
+hiddenimports += collect_submodules('superqt.fonticon')
+
+print("Loaded superqt!", hiddenimports)

installer_hooks/hook-vispy.py

@@ -0,0 +1,11 @@
+from PyInstaller.utils.hooks import collect_data_files
+from vispy.app.backends import CORE_BACKENDS
+
+
+datas = collect_data_files('vispy')
+
+hiddenimports = ["vispy.ext"]
+
+# adding all backends is required for vispy.sys_info() to work
+hiddenimports += ["vispy.app.backends." + b[1] for b in CORE_BACKENDS]
+hiddenimports += ["vispy.app.backends._test"]

motile_tracker/__init__.py

@@ -0,0 +1,5 @@
+try:
+    from ._version import version as __version__
+except ImportError:
+    # package is not installed
+    __version__ = "uninstalled"

motile_tracker/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.0.1.dev0'
+__version_tuple__ = version_tuple = (0, 0, 1, 'dev0')

motile_tracker/application_menus/__init__.py

@@ -0,0 +1,3 @@
+from .main_app import MainApp  # noqa
+from .editing_menu import EditingMenu  # noqa
+from .menu_widget import MenuWidget  # noqa

motile_tracker/application_menus/editing_menu.py

@@ -0,0 +1,100 @@
+import napari
+from qtpy.QtWidgets import (
+    QGroupBox,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from motile_tracker.data_views.views_coordinator.tracks_viewer import TracksViewer
+
+
+class EditingMenu(QWidget):
+    def __init__(self, viewer: napari.Viewer):
+        super().__init__()
+
+        self.tracks_viewer = TracksViewer.get_instance(viewer)
+        self.tracks_viewer.selected_nodes.list_updated.connect(self.update_buttons)
+        layout = QVBoxLayout()
+
+        node_box = QGroupBox("Edit Node(s)")
+        node_box.setMaximumHeight(60)
+        node_box_layout = QVBoxLayout()
+
+        self.delete_node_btn = QPushButton("Delete [D]")
+        self.delete_node_btn.clicked.connect(self.tracks_viewer.delete_node)
+        self.delete_node_btn.setEnabled(False)
+        # self.split_node_btn = QPushButton("Set split [S]")
+        # self.split_node_btn.clicked.connect(self.tracks_viewer.set_split_node)
+        # self.split_node_btn.setEnabled(False)
+        # self.endpoint_node_btn = QPushButton("Set endpoint [E]")
+        # self.endpoint_node_btn.clicked.connect(self.tracks_viewer.set_endpoint_node)
+        # self.endpoint_node_btn.setEnabled(False)
+        # self.linear_node_btn = QPushButton("Set linear [C]")
+        # self.linear_node_btn.clicked.connect(self.tracks_viewer.set_linear_node)
+        # self.linear_node_btn.setEnabled(False)
+
+        node_box_layout.addWidget(self.delete_node_btn)
+        # node_box_layout.addWidget(self.split_node_btn)
+        # node_box_layout.addWidget(self.endpoint_node_btn)
+        # node_box_layout.addWidget(self.linear_node_btn)
+
+        node_box.setLayout(node_box_layout)
+
+        edge_box = QGroupBox("Edit Edge(s)")
+        edge_box.setMaximumHeight(100)
+        edge_box_layout = QVBoxLayout()
+
+        self.delete_edge_btn = QPushButton("Break [B]")
+        self.delete_edge_btn.clicked.connect(self.tracks_viewer.delete_edge)
+        self.delete_edge_btn.setEnabled(False)
+        self.create_edge_btn = QPushButton("Add [A]")
+        self.create_edge_btn.clicked.connect(self.tracks_viewer.create_edge)
+        self.create_edge_btn.setEnabled(False)
+
+        edge_box_layout.addWidget(self.delete_edge_btn)
+        edge_box_layout.addWidget(self.create_edge_btn)
+
+        edge_box.setLayout(edge_box_layout)
+
+        self.undo_btn = QPushButton("Undo (Z)")
+        self.undo_btn.clicked.connect(self.tracks_viewer.undo)
+
+        self.redo_btn = QPushButton("Redo (R)")
+        self.redo_btn.clicked.connect(self.tracks_viewer.redo)
+
+        layout.addWidget(node_box)
+        layout.addWidget(edge_box)
+        layout.addWidget(self.undo_btn)
+        layout.addWidget(self.redo_btn)
+
+        self.setLayout(layout)
+        self.setMaximumHeight(300)
+
+    def update_buttons(self):
+        """Set the buttons to enabled/disabled depending on the currently selected nodes"""
+
+        n_selected = len(self.tracks_viewer.selected_nodes)
+        if n_selected == 0:
+            self.delete_node_btn.setEnabled(False)
+            # self.split_node_btn.setEnabled(False)
+            # self.endpoint_node_btn.setEnabled(False)
+            # self.linear_node_btn.setEnabled(False)
+            self.delete_edge_btn.setEnabled(False)
+            self.create_edge_btn.setEnabled(False)
+
+        elif n_selected == 2:
+            self.delete_node_btn.setEnabled(True)
+            # self.split_node_btn.setEnabled(True)
+            # self.endpoint_node_btn.setEnabled(True)
+            # self.linear_node_btn.setEnabled(True)
+            self.delete_edge_btn.setEnabled(True)
+            self.create_edge_btn.setEnabled(True)
+
+        else:
+            self.delete_node_btn.setEnabled(True)
+            # self.split_node_btn.setEnabled(True)
+            # self.endpoint_node_btn.setEnabled(True)
+            # self.linear_node_btn.setEnabled(True)
+            self.delete_edge_btn.setEnabled(False)
+            self.create_edge_btn.setEnabled(False)

motile_tracker/application_menus/main_app.py

@@ -0,0 +1,26 @@
+import napari
+from qtpy.QtWidgets import (
+    QVBoxLayout,
+    QWidget,
+)
+
+from motile_tracker.data_views.views.tree_view.tree_widget import TreeWidget
+
+from .menu_widget import MenuWidget
+
+
+class MainApp(QWidget):
+    """Combines the different tracker widgets for faster dock arrangement"""
+
+    def __init__(self, viewer: napari.Viewer):
+        super().__init__()
+
+        menu_widget = MenuWidget(viewer)
+        tree_widget = TreeWidget(viewer)
+
+        viewer.window.add_dock_widget(tree_widget, area="bottom", name="Tree View")
+
+        layout = QVBoxLayout()
+        layout.addWidget(menu_widget)
+
+        self.setLayout(layout)

motile_tracker/application_menus/menu_widget.py

@@ -0,0 +1,32 @@
+import napari
+from qtpy.QtWidgets import QScrollArea, QTabWidget, QVBoxLayout
+
+from motile_tracker.application_menus.editing_menu import EditingMenu
+from motile_tracker.data_views.views_coordinator.tracks_viewer import TracksViewer
+from motile_tracker.motile.menus.motile_widget import MotileWidget
+
+
+class MenuWidget(QScrollArea):
+    """Combines the different tracker menus into tabs for cleaner UI"""
+
+    def __init__(self, viewer: napari.Viewer):
+        super().__init__()
+
+        tracks_viewer = TracksViewer.get_instance(viewer)
+
+        motile_widget = MotileWidget(viewer)
+        editing_widget = EditingMenu(viewer)
+
+        tabwidget = QTabWidget()
+
+        tabwidget.addTab(motile_widget, "Track with Motile")
+        tabwidget.addTab(editing_widget, "Edit Tracks")
+        tabwidget.addTab(tracks_viewer.tracks_list, "Results List")
+
+        layout = QVBoxLayout()
+        layout.addWidget(tabwidget)
+
+        self.setWidget(tabwidget)
+        self.setWidgetResizable(True)
+
+        self.setLayout(layout)

motile_tracker/data_model/__init__.py

@@ -0,0 +1,4 @@
+from .tracks import Tracks  # noqa
+from .solution_tracks import SolutionTracks  # noqa
+from .node_type import NodeType  # noqa
+from .tracks_controller import TracksController  # noqa

motile_tracker/data_model/action_history.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .actions import TracksAction
+
+
+class ActionHistory:
+    """An action history implementing the ideas from this blog:
+    https://github.com/zaboople/klonk/blob/master/TheGURQ.md
+    Essentially, if you go back and change something after undo-ing, you can always get
+    back to every state if you undo far enough (instead of throwing out
+    the undone actions)
+    """
+
+    def __init__(self):
+        self.undo_stack: list[TracksAction] = []  # list of actions that can be undone
+        self.redo_stack: list[TracksAction] = []  # list of actions that can be redone
+
+    @property
+    def undo_pointer(self):
+        return len(self.undo_stack) - len(self.redo_stack) - 1
+
+    def add_new_action(self, action: TracksAction) -> None:
+        """Add a newly performed action to the history.
+        Args:
+            action (TracksAction): The new action to be added to the history.
+        """
+        if len(self.redo_stack) > 0:
+            # add all the redo stuff to the undo stack, so that both the originial and
+            # inverse are on the stack
+            self.undo_stack.extend(self.redo_stack)
+            self.redo_stack = []
+        self.undo_stack.append(action)
+
+    def undo(self) -> bool:
+        """Undo the last performed action
+
+        Returns:
+            bool: True if an action was undone, and False
+            if there was no previous action to undo.
+        """
+        if self.undo_pointer < 0:
+            return False
+        else:
+            action = self.undo_stack[self.undo_pointer]
+            inverse = action.inverse()
+            self.redo_stack.append(inverse)
+            return True
+
+    def redo(self) -> bool:
+        """Redo the last undone action
+
+        Returns:
+            bool: True if an action was redone, and False
+            if there was no undone action to redo.
+        """
+        if len(self.redo_stack) == 0:
+            return False
+        else:
+            action = self.redo_stack.pop(-1)
+            # apply the inverse but don't save it
+            # (the original is already on the undo stack)
+            action.inverse()
+            return True