PeriphNeuronStim/nerve_widget.py at master · lkdr23/PeriphNeuronStim · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
import matplotlib
matplotlib.use('Qt5Agg')

from PyQt5.QtCore import pyqtSignal, Qt
from PyQt5 import uic, QtGui, QtWidgets
from PyQt5.QtWidgets import QApplication, QWidget, QInputDialog, QLineEdit, QFileDialog

import neuron_sim as ns
import database

Ui_NerveWidget, QWidget_Nerve = uic.loadUiType("ui_nerve_widget.ui")
Ui_NerveDimensionWidget, QWidget_NerveDimensions = uic.loadUiType("ui_nerve_dimension_widget.ui")

rmg_diameter_list = ["16.0", "15.0", "14.0", "12.8", "11.5", "10.0", "8.7", "7.3", "5.7"]

# This class does:


class NerveWidget(QWidget_Nerve, Ui_NerveWidget):
    e_field_changed = pyqtSignal()

    def __init__(self, scaling, nseg_node, nseg_internode, parent = None):
        super(NerveWidget, self).__init__(parent)

        self.setupUi(self)

        self.scaling = scaling  # ui and CST uses mm, we use um; elements from gui and e_field are scaled by self.scaling
        self.nseg_node = nseg_node
        self.nseg_internode = nseg_internode
        self.axon_list_item_model = QtGui.QStandardItemModel(self.axon_list_view)

        # self.nerve_dimension_button.setEnabled(False)
        self.nerve_dimension_widget = nerveDimensionWidget()

        self.anatomical_nerve = None
        self.custom_nerve = self.add_custom_nerve()

        self.axon_diam_combo_box.setVisible(False)
        self.axon_diam_combo_box.addItems(rmg_diameter_list)

        # self.nerve_name_line_edit.setText('Default')

        self.add_axon_button.clicked.connect(self.add_axon_to_nerve)
        self.delete_axon_button.clicked.connect(self.delete_axon)

        self.axon_type_combo_box.currentTextChanged.connect(self.set_axon_diam_widget)

        self.nerve_dimension_button.clicked.connect(self.show_nerve_dimension_widget)

        self.nerve_dimension_widget.x_spin_box.valueChanged.connect(self.set_nerve_x)
        self.nerve_dimension_widget.y_spin_box.valueChanged.connect(self.set_nerve_y)
        self.nerve_dimension_widget.z_spin_box.valueChanged.connect(self.set_nerve_z)
        self.nerve_dimension_widget.angle_spin_box.valueChanged.connect(self.set_nerve_angle)
        self.nerve_dimension_widget.length_spin_box.valueChanged.connect(self.set_nerve_length)
        self.nerve_dimension_widget.diam_spin_box.valueChanged.connect(self.set_nerve_diam)

    def add_custom_nerve(self):
        custom_nerve = database.CustomNerve(
            x=self.nerve_dimension_widget.x_spin_box.value() * self.scaling,
            y=self.nerve_dimension_widget.y_spin_box.value() * self.scaling,
            z=self.nerve_dimension_widget.z_spin_box.value() * self.scaling,
            resolution=self.nerve_dimension_widget.res_spin_box.value(),
            angle=self.nerve_dimension_widget.angle_spin_box.value(),
            length=self.nerve_dimension_widget.length_spin_box.value() * self.scaling,
            nerv_diam=self.nerve_dimension_widget.diam_spin_box.value(),
            name='')
        self.e_field_changed.emit()
        return custom_nerve

    def add_anatomical_nerve(self, nerve_shape):
        self.anatomical_nerve = nerve_shape
        self.warningLabel.setText('Available')

    def get_selected_nerve(self):
        if self.anatomicalRadioButton.isChecked():
            selected_nerve = self.anatomical_nerve
        else:
            selected_nerve = self.custom_nerve
        return selected_nerve
    # def delete_nerve(self):
    #     if not self.nerve_dict:
    #         return
    #     self.nerve_dict.pop(self.nerve_combo_box.currentText())
    #     self.nerve_list_item_model.removeRow(self.nerve_combo_box.currentIndex())
    #     self.nerve_combo_box.setModel(self.nerve_list_item_model)
    #     self.update_axon_list()
    #     self.e_field_changed.emit()

    def add_axon_to_nerve(self):
        selected_nerve = self.get_selected_nerve()
        axon_type = self.axon_type_combo_box.currentText()
        if self.axon_type_combo_box.currentText() == "RMG":
            diameter = float(self.axon_diam_combo_box.currentText())
        else:
            diameter = self.axon_diam_spin_box.value()
        print(selected_nerve.x[0])
        model_info = ns.AxonInformation(selected_nerve.x[0], selected_nerve.y[0], selected_nerve.z[0], diameter,
                                        axon_type, self.nseg_node, self.nseg_internode)
        print('Check if i was here')
        selected_nerve.axon_infos_list.append(model_info)
        print('Check if i was here')
        self.update_axon_list()

    def update_axon_list(self):
        selected_nerve = self.get_selected_nerve()
        self.axon_list_item_model.clear()
        for axon_info in selected_nerve.axon_infos_list:
            item = QtGui.QStandardItem(axon_info.axon_type + "_" + str(axon_info.diameter))
            self.axon_list_item_model.appendRow(item)
        self.axon_list_view.setModel(self.axon_list_item_model)

    def update_axons(self):
        selected_nerve = self.get_selected_nerve()
        for axon_info in selected_nerve.axon_infos_list:
            axon_info.x = selected_nerve.x
            axon_info.y = selected_nerve.y
            axon_info.z = selected_nerve.z
            axon_info.angle = selected_nerve.angle
            axon_info.length = selected_nerve.length

    def delete_axon(self):
        selected_nerve = self.get_selected_nerve()
        if not self.axon_list_view.currentIndex().isValid():
            return
        selected_index = self.axon_list_view.currentIndex()
        del selected_nerve.axon_infos_list[selected_index.row()]
        self.update_axon_list()

    def set_axon_diam_widget(self):
        if self.axon_type_combo_box.currentText() == "RMG":
            self.axon_diam_combo_box.setVisible(True)
            self.axon_diam_spin_box.setVisible(False)
        else:
            self.axon_diam_combo_box.setVisible(False)
            self.axon_diam_spin_box.setVisible(True)

    def show_nerve_dimension_widget(self):
        self.nerve_dimension_widget.show()

    def change_nerve_property_box(self):
        selected_nerve = self.custom_nerve
        self.update_axon_list()
        self.nerve_dimension_widget.name_label.setText(self.nerve_combo_box.currentText())
        self.nerve_dimension_widget.x_spin_box.setValue(selected_nerve.x / self.scaling)
        self.nerve_dimension_widget.y_spin_box.setValue(selected_nerve.y / self.scaling)
        self.nerve_dimension_widget.z_spin_box.setValue(selected_nerve.z / self.scaling)
        self.nerve_dimension_widget.angle_spin_box.setValue(selected_nerve.angle)
        self.nerve_dimension_widget.length_spin_box.setValue(selected_nerve.length / self.scaling)
        self.nerve_dimension_widget.diam_spin_box.setValue(selected_nerve.nerve_diameter)
        # self.e_field_changed.emit()

    def set_nerve_x(self, value):
        selected_nerve = self.custom_nerve
        selected_nerve.x = value * self.scaling  # convert from mm to um
        self.update_axons()
        self.e_field_changed.emit()

    def set_nerve_y(self, value):
        selected_nerve = self.custom_nerve
        selected_nerve.y = value * self.scaling  # convert from mm to um
        self.update_axons()
        self.e_field_changed.emit()

    def set_nerve_z(self, value):
        selected_nerve = self.custom_nerve
        selected_nerve.z = value * self.scaling  # convert from mm to um
        self.update_axons()
        self.e_field_changed.emit()

    def set_nerve_angle(self, value):
        selected_nerve = self.custom_nerve
        selected_nerve.angle = value
        self.update_axons()
        self.e_field_changed.emit()

    def set_nerve_length(self, value):
        selected_nerve = self.custom_nerve
        selected_nerve.length = value * self.scaling  # convert from mm to um
        self.update_axons()
        self.e_field_changed.emit()

    def set_nerve_diam(self, value):
        selected_nerve = self.custom_nerve
        selected_nerve.nerve_diameter = value
        self.e_field_changed.emit()


class nerveDimensionWidget(QWidget_NerveDimensions, Ui_NerveDimensionWidget):

    def __init__(self, parent = None):
        super(nerveDimensionWidget, self).__init__(parent)

        self.setupUi(self)