Treeview Widget.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Laura Chapman\n",
    "# Script for developing statistical tools for Glue\n",
    "# As of 7/9/2018 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: W03: w5_psc.vot:11:0: W03: Implicitly generating an ID from a name 'J/ApJ/688/1142/table2' -> 'J_ApJ_688_1142_table2' [astropy.io.votable.xmlutil]\n",
      "WARNING:astropy:W03: w5_psc.vot:11:0: W03: Implicitly generating an ID from a name 'J/ApJ/688/1142/table2' -> 'J_ApJ_688_1142_table2'\n",
      "WARNING: W03: w5_psc.vot:17:0: W03: Implicitly generating an ID from a name '-ref' -> '_-ref' [astropy.io.votable.xmlutil]\n",
      "WARNING:astropy:W03: w5_psc.vot:17:0: W03: Implicitly generating an ID from a name '-ref' -> '_-ref'\n",
      "WARNING: W03: w5_psc.vot:18:0: W03: Implicitly generating an ID from a name '-out.max' -> '_-out.max' [astropy.io.votable.xmlutil]\n",
      "WARNING:astropy:W03: w5_psc.vot:18:0: W03: Implicitly generating an ID from a name '-out.max' -> '_-out.max'\n",
      "WARNING: W03: w5_psc.vot:63:0: W03: Implicitly generating an ID from a name '[3.6]' -> '__3.6_' [astropy.io.votable.xmlutil]\n",
      "WARNING:astropy:W03: w5_psc.vot:63:0: W03: Implicitly generating an ID from a name '[3.6]' -> '__3.6_'\n",
      "WARNING: W03: w5_psc.vot:66:0: W03: Implicitly generating an ID from a name '[4.5]' -> '__4.5_' [astropy.io.votable.xmlutil]\n",
      "WARNING:astropy:W03: w5_psc.vot:66:0: W03: Implicitly generating an ID from a name '[4.5]' -> '__4.5_'\n",
      "WARNING: W03: w5_psc.vot:69:0: W03: Implicitly generating an ID from a name '[5.8]' -> '__5.8_' [astropy.io.votable.xmlutil]\n",
      "WARNING:astropy:W03: w5_psc.vot:69:0: W03: Implicitly generating an ID from a name '[5.8]' -> '__5.8_'\n",
      "WARNING: W03: w5_psc.vot:72:0: W03: Implicitly generating an ID from a name '[8.0]' -> '__8.0_' [astropy.io.votable.xmlutil]\n",
      "WARNING:astropy:W03: w5_psc.vot:72:0: W03: Implicitly generating an ID from a name '[8.0]' -> '__8.0_'\n",
      "WARNING: W03: w5_psc.vot:75:0: W03: Implicitly generating an ID from a name '[24]' -> '__24_' [astropy.io.votable.xmlutil]\n",
      "WARNING:astropy:W03: w5_psc.vot:75:0: W03: Implicitly generating an ID from a name '[24]' -> '__24_'\n",
      "WARNING: W03: w5_psc.vot:81:0: W03: Implicitly generating an ID from a name '[4.5] - [5.8]' -> '__4.5__-__5.8_' [astropy.io.votable.xmlutil]\n",
      "WARNING:astropy:W03: w5_psc.vot:81:0: W03: Implicitly generating an ID from a name '[4.5] - [5.8]' -> '__4.5__-__5.8_'\n",
      "WARNING: W03: w5_psc.vot:84:0: W03: Implicitly generating an ID from a name '[5.8] - [8.0]' -> '__5.8__-__8.0_' (suppressing further warnings of this type...) [astropy.io.votable.xmlutil]\n",
      "WARNING:astropy:W03: w5_psc.vot:84:0: W03: Implicitly generating an ID from a name '[5.8] - [8.0]' -> '__5.8__-__8.0_' (suppressing further warnings of this type...)\n"
     ]
    }
   ],
   "source": [
    "# Basic code that imports glue and loads in and links the data\n",
    "\n",
    "import sys\n",
    "from glue.core.data_factories import load_data\n",
    "from glue.core import DataCollection\n",
    "from glue.core.link_helpers import LinkSame\n",
    "from glue.app.qt.application import GlueApplication\n",
    "from glue.viewers.image.qt import ImageViewer\n",
    "from glue_vispy_viewers.volume.volume_viewer import VispyVolumeViewer\n",
    "\n",
    "image_filename='w5.fits'\n",
    "catalog_filename='w5_psc.vot'\n",
    "\n",
    "#load 2 datasets from files\n",
    "catalog = load_data(catalog_filename)\n",
    "image = load_data(image_filename)\n",
    "\n",
    "dc = DataCollection([catalog,image])\n",
    "\n",
    "# link positional information\n",
    "dc.add_link(LinkSame(catalog.id['RAJ2000'], image.id['Right Ascension']))\n",
    "dc.add_link(LinkSame(catalog.id['DEJ2000'], image.id['Declination']))\n",
    "\n",
    "#Create subset based on filament mask\n",
    "ra_state=(image.id['Right Ascension'] > 44) & (image.id['Right Ascension'] < 46)\n",
    "subset_group=dc.new_subset_group('RA_Selection',ra_state)\n",
    "subset_group.style.color = '#0000FF'\n",
    "\n",
    "de_state = image.id['Declination'] > 60\n",
    "subset_group1 = dc.new_subset_group('DE_Selection', de_state)\n",
    "subset_group1.style.color = '#FF0000'\n",
    "\n",
    "j_state = catalog.id['Jmag'] > 14\n",
    "subset_group2 = dc.new_subset_group('Jmag Selection', j_state)\n",
    "subset_group2.style.color = '#00FF00'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import glue.utils.array as gua\n",
    "import glue.core.data as gcd\n",
    "import pandas as pd\n",
    "from pandas import DataFrame\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nNotes:\\n\\nNeeds to be able to select multiple rows at a time to add to the table.\\nThis seems to be reliant on detecting the mouse release event, though QTreeView only \\nprovides built in signals for pressed and clicked. \\n\\nWhen switching from the two tree views, the equivalent rows that were selected in the \\nother view should be selected. Haven't figured out how to select rows in qtreeview. \\n\\n\""
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# format for keys\n",
    "\n",
    "# subset (data set)component\n",
    "\n",
    "'''\n",
    "Notes:\n",
    "\n",
    "Needs to be able to select multiple rows at a time to add to the table.\n",
    "This seems to be reliant on detecting the mouse release event, though QTreeView only \n",
    "provides built in signals for pressed and clicked. \n",
    "\n",
    "When switching from the two tree views, the equivalent rows that were selected in the \n",
    "other view should be selected. Haven't figured out how to select rows in qtreeview. \n",
    "\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QApplication instance already exists: <PyQt5.QtWidgets.QApplication object at 0x151a27a948>\n"
     ]
    },
    {
     "ename": "SystemExit",
     "evalue": "0",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\u001b[0;31m:\u001b[0m 0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/laurachapman/anaconda/envs/glueviz-dev/lib/python3.6/site-packages/IPython/core/interactiveshell.py:2971: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "from  PyQt5.QtCore  import QAbstractItemModel, pyqtSignal, QSize, QFile, QIODevice, QModelIndex, Qt, pyqtSlot, QVariant, QItemSelectionModel\n",
    "from PyQt5.QtWidgets import QSizePolicy, QTreeView, QRadioButton, QAbstractScrollArea, QSpinBox, QToolButton, QHeaderView, QAbstractItemView, QApplication, QLabel, QTreeView, QComboBox, QCheckBox, QWidget, QPushButton, QHBoxLayout, QFrame, QTableView, QGroupBox, QDialog, QVBoxLayout, QLabel, QGridLayout\n",
    "from PyQt5 import QtCore, QtWidgets, QtGui\n",
    "from PyQt5.QtGui import QStandardItemModel, QStandardItem\n",
    "from decimal import getcontext, Decimal\n",
    "from IPython.display import display, HTML\n",
    "from PyQt5.QtGui import *\n",
    "import sys\n",
    "from qtpy import compat\n",
    "from glue.icons.qt import helpers\n",
    "\n",
    "class pandasModel(QtCore.QAbstractTableModel):\n",
    "    # Set up the data in a form that allows it to be added to qt widget\n",
    "    def __init__(self, df, dc, parent=None):\n",
    "        QtCore.QAbstractTableModel.__init__(self, parent)\n",
    "        self.dc = dc\n",
    "        self.data_frame = df\n",
    "        self.subset_labels = []\n",
    "        \n",
    "        # Create an array of subset labels\n",
    "        for i in range(0, len(self.dc.subset_groups)):\n",
    "            self.subset_labels.append(dc.subset_groups[i].label)\n",
    "        \n",
    "        super(pandasModel, self).__init__(parent)      \n",
    "\n",
    "    def rowCount(self, parent=None):\n",
    "        return len(self.data_frame.values)\n",
    "\n",
    "    def columnCount(self, parent=None):\n",
    "        return self.data_frame.columns.size\n",
    "\n",
    "    def data(self, index, role=Qt.DisplayRole):\n",
    "        if index.isValid():\n",
    "            if role == Qt.BackgroundRole:\n",
    "                # Get the data index and set the tranparency\n",
    "                data = str(self.data_frame.values[index.row()][1])\n",
    "                data_index = np.where(data == np.asarray(self.dc.labels))[0][0]  \n",
    "                transparency = 60\n",
    "                \n",
    "                # If it is a subset find the color and color accordingly\n",
    "                if self.data_frame.values[index.row()][0] != '--':\n",
    "                    subset = str(self.data_frame.values[index.row()][0])\n",
    "                    subset_index = np.where(subset == np.asarray(self.subset_labels))[0][0]\n",
    "                    color = dc[data_index].subsets[subset_index].style.color\n",
    "                    q_color = QColor(color)\n",
    "                    rgb_color = q_color.getRgb()\n",
    "                    \n",
    "                    return QBrush(QColor(rgb_color[0], rgb_color[1], rgb_color[2], transparency))\n",
    "                \n",
    "                # If it is a dataset find the color and color accordingly \n",
    "                else:\n",
    "                    color = dc[data_index].style.color\n",
    "                    q_color = QColor(color)\n",
    "                    rgb_color = q_color.getRgb()\n",
    "\n",
    "                    return QBrush(QColor(rgb_color[0], rgb_color[1], rgb_color[2], transparency))\n",
    "                \n",
    "            elif role == Qt.DisplayRole:\n",
    "                return QVariant(str(\n",
    "                    self.data_frame.values[index.row()][index.column()]))\n",
    "        return QVariant()\n",
    "    \n",
    "    def headerData(self, col, orientation, role):\n",
    "        if orientation == Qt.Horizontal and role == Qt.DisplayRole:\n",
    "            return QVariant(self.data_frame.columns[col])\n",
    "        if orientation == Qt.Vertical and role == Qt.DisplayRole:\n",
    "            return QVariant(self.data_frame.index[col])\n",
    "        return QVariant()  \n",
    "    \n",
    "    def sort(self, column, order):\n",
    "        colname = self.data_frame.columns.tolist()[column]\n",
    "        self.layoutAboutToBeChanged.emit()\n",
    "        self.data_frame.sort_values(colname, ascending= order == QtCore.Qt.AscendingOrder, inplace=True)\n",
    "        self.data_frame.reset_index(inplace=True, drop=True)\n",
    "        self.layoutChanged.emit()   \n",
    "        \n",
    "class StatsGui(QWidget):\n",
    "    ''' \n",
    "    This class accepts a glue data collection object, and builds an interactive window\n",
    "    to display basic statistics (e.g. mean, median, mode) about each dataset\n",
    "    '''\n",
    "    \n",
    "    released = QtCore.pyqtSignal(object)\n",
    "    \n",
    "    def __init__(self,dc):\n",
    "        \n",
    "        # Initialize the object as a QWidget\n",
    "        QWidget.__init__(self)\n",
    "        \n",
    "        #Save the datacollection object as an attribute of class StatsGui\n",
    "        self.dc=dc\n",
    "        \n",
    "        #Set the title of the main GUI window\n",
    "        self.setWindowTitle('Statistics')\n",
    "        \n",
    "        # Set up dicts for row indices\n",
    "        self.subset_dict = dict()\n",
    "        self.component_dict = dict()\n",
    "        \n",
    "        self.selected_dict = dict()\n",
    "        self.selected_indices = []\n",
    "        \n",
    "        # Set up the headings\n",
    "        self.headings = ('Subset', 'Dataset', 'Component','Mean', 'Median', 'Minimum', 'Maximum', 'Sum')\n",
    "        \n",
    "        #################Set up the QTableView Widget#############################\n",
    "        self.table = QTableView(self)\n",
    "        self.table.setSortingEnabled(True)\n",
    "        self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)\n",
    "        self.table.verticalHeader().setVisible(False)\n",
    "        \n",
    "        #Set the table headings   \n",
    "        self.data_frame = pd.DataFrame(columns=self.headings) \n",
    "        self.data_accurate = pd.DataFrame(columns=self.headings)\n",
    "        self.model = pandasModel(self.data_frame, self.dc)\n",
    "\n",
    "        self.table.setModel(self.model) \n",
    "        \n",
    "        #Set up tree view and fix it to the top half of the window\n",
    "        self.treeview = QTreeView(self)\n",
    "\n",
    "        # Set the default clicking behavior to be row selection\n",
    "        self.treeview.setSelectionBehavior(QAbstractItemView.SelectRows)\n",
    "        \n",
    "        # Set up expand all, collapse all, select all and deselect all buttons\n",
    "        \n",
    "        # Layout for expand/collapse/select/deselect\n",
    "        layout_left_options = QHBoxLayout()\n",
    "        \n",
    "        self.expand_data = QToolButton(self)\n",
    "        self.expand_data.setText(\"Expand all data and subsets\")\n",
    "        self.expand_data.clicked.connect(self.expandClicked)\n",
    "        layout_left_options.addWidget(self.expand_data)\n",
    "        \n",
    "        self.all = QToolButton(self)\n",
    "        self.all.setText('Select all')\n",
    "        self.all.clicked.connect(self.allClicked)\n",
    "        layout_left_options.addWidget(self.all)\n",
    "        \n",
    "        self.none = QToolButton(self)\n",
    "        self.none.setText('Deselect all')\n",
    "        self.none.clicked.connect(self.noneClicked)\n",
    "        layout_left_options.addWidget(self.none)\n",
    "        \n",
    "        # Set default significant figures to 5\n",
    "        getcontext().prec = 5\n",
    "        \n",
    "        # Set up past selected items\n",
    "        self.past_selected = []\n",
    "        \n",
    "        # Sort by subsets as a default\n",
    "        self.sortBySubsets()\n",
    "        self.component_mode = False\n",
    "\n",
    "        # Set up the combo box for users to choose the number of significant figures in the table\n",
    "        \n",
    "        # Set up bottom options layout\n",
    "        layout_bottom_options = QHBoxLayout()\n",
    "        \n",
    "        self.siglabel = QLabel(self)\n",
    "        self.siglabel.setText('Number of decimals:')\n",
    "        layout_bottom_options.addWidget(self.siglabel)\n",
    "        \n",
    "        self.num_sigs = 3\n",
    "        \n",
    "        self.sigfig = QSpinBox(self)\n",
    "        self.sigfig.setRange(1,10)\n",
    "        self.sigfig.setValue(self.num_sigs)\n",
    "        self.sigfig.valueChanged.connect(self.sigchange)\n",
    "        layout_bottom_options.addWidget(self.sigfig)\n",
    "        \n",
    "        # Allow user to pick scientific notation or nonscientific notation\n",
    "        self.sci_notation = QRadioButton(self)\n",
    "        self.sci_notation.setText('Scientific notation')\n",
    "        self.sci_notation.setChecked(True)\n",
    "        self.isSci = True\n",
    "        self.sci_notation.toggled.connect(self.notation)\n",
    "        \n",
    "        self.stan_notation = QRadioButton(self)\n",
    "        self.stan_notation.setText('Standard notation')\n",
    "        self.sci_notation.toggled.connect(self.notation)\n",
    "        \n",
    "        layout_bottom_options.addWidget(self.sci_notation)\n",
    "        layout_bottom_options.addWidget(self.stan_notation)\n",
    "        \n",
    "        # Export to file button\n",
    "        self.export = QPushButton(self)\n",
    "        self.export.setText('Export to file')\n",
    "        self.export.clicked.connect(self.exportToFile)\n",
    "        layout_bottom_options.addWidget(self.export)\n",
    "        \n",
    "        # Set up the toggle button to switch tree sorting modes\n",
    "        self.switch_mode = QToolButton(self)\n",
    "        self.switch_mode.setText('Sort tree by components')\n",
    "        self.switch_mode.clicked.connect(self.switchMode)\n",
    "        layout_left_options.addWidget(self.switch_mode)\n",
    "        \n",
    "        # Add instructions to sort the table\n",
    "        self.how = QLabel(self)\n",
    "        self.how.setText('Click each header to sort table')\n",
    "        layout_left_options.addWidget(self.how)\n",
    "        \n",
    "        layout_table = QHBoxLayout()\n",
    "        layout_table.addWidget(self.table)\n",
    "        layout_table.stretch(10)\n",
    "\n",
    "        # Finish nesting all the layouts\n",
    "        main_layout = QVBoxLayout()\n",
    "        \n",
    "        main_layout.addWidget(self.treeview)\n",
    "        main_layout.addLayout(layout_left_options)\n",
    "        main_layout.addLayout(layout_table)\n",
    "        main_layout.addLayout(layout_bottom_options)\n",
    "        \n",
    "        self.setLayout(main_layout)\n",
    "        \n",
    "        # Set up dict for caching\n",
    "        self.cache_stash = dict()\n",
    "        \n",
    "        # Set up bool for keeping track of component_mode\n",
    "    \n",
    "    def myPressedEvent (self, currentQModelIndex):\n",
    "        ''' \n",
    "        Every time a row (or rows) in the tree view is clicked:\n",
    "        if it is selected, add it to the table\n",
    "        if it is deselected, remove it from the table\n",
    "        ''' \n",
    "            \n",
    "        # Get the indexes of all the selected components\n",
    "        self.selected_indices = self.treeview.selectionModel().selectedRows()\n",
    "\n",
    "        newly_selected = np.setdiff1d(self.selected_indices, self.past_selected)\n",
    "            \n",
    "        for index in range (0, len(newly_selected)):\n",
    "                \n",
    "            # Check which view mode the tree is in to get the correct indices\n",
    "            if not self.component_mode:\n",
    "                if newly_selected[index].parent().parent().parent().row() == -1:\n",
    "                    # Whole data sets\n",
    "                    data_i = newly_selected[index].parent().row()\n",
    "                    comp_i = newly_selected[index].row()\n",
    "                    subset_i = -1\n",
    "                else:\n",
    "                    # Subsets\n",
    "                    data_i = newly_selected[index].parent().row()\n",
    "                    comp_i = newly_selected[index].row()\n",
    "                    subset_i = newly_selected[index].parent().parent().row()\n",
    "            \n",
    "            else:\n",
    "                data_i = newly_selected[index].parent().parent().row()\n",
    "                comp_i = newly_selected[index].parent().row()\n",
    "                subset_i = newly_selected[index].row() - 1\n",
    "\n",
    "            is_subset = (subset_i != -1)\n",
    "\n",
    "            # Check if its a subset and if so run subset stats\n",
    "            if is_subset: \n",
    "                self.runSubsetStats(subset_i, data_i, comp_i)\n",
    "\n",
    "            else:\n",
    "                # Run standard data stats\n",
    "                self.runDataStats(data_i, comp_i)   \n",
    "            \n",
    "        newly_dropped = np.setdiff1d(self.past_selected, self.selected_indices)\n",
    "            \n",
    "        for index in range (0, len(newly_dropped)):\n",
    "                \n",
    "            # Check which view mode the tree is in to get the correct indices\n",
    "            if not self.component_mode:\n",
    "                data_i = newly_dropped[index].parent().row()\n",
    "                comp_i = newly_dropped[index].row()\n",
    "                subset_i = newly_dropped[index].parent().parent().row()\n",
    "            \n",
    "            else:\n",
    "                data_i = newly_dropped[index].parent().parent().row()\n",
    "                comp_i = newly_dropped[index].parent().row()\n",
    "                subset_i = newly_dropped[index].row() - 1\n",
    "            \n",
    "            is_subset = newly_dropped[index].parent().parent().parent().row() == 1 or (self.switch_mode.text() == 'Sort tree by subsets' and subset_i != -1)\n",
    "\n",
    "            if is_subset:\n",
    "                try:\n",
    "                    # Get the indices that match the component, dataset, and subset requirements\n",
    "                    idx_c = np.where(self.data_frame['Component'] == self.dc[data_i].components[comp_i].label)\n",
    "                    idx_d = np.where(self.data_frame['Dataset'] == self.dc[data_i].label)\n",
    "                    idx_s = np.where(self.data_frame['Subset'] == self.dc[data_i].subsets[subset_i].label)\n",
    "                    idx1 = np.intersect1d(idx_c, idx_d)\n",
    "                    idx2 = np.intersect1d(idx1, idx_s)\n",
    "\n",
    "                    self.data_frame = self.data_frame.drop(idx2)\n",
    "                except:\n",
    "                    pass\n",
    "\n",
    "            else:\n",
    "                try:\n",
    "                # Find the index in the table of the unchecked element, if it's in the table\n",
    "\n",
    "                    # Find the matching component and dataset indices and intersect them to get the unique index\n",
    "                    idx_c = np.where(self.data_frame['Component'] == self.dc[data_i].components[comp_i].label)\n",
    "                    idx_d = np.where(self.data_frame['Dataset'] == self.dc[data_i].label)\n",
    "                    idx_s = np.where(self.data_frame['Subset'] == '--')\n",
    "                    idx1 = np.intersect1d(idx_c, idx_d)\n",
    "                    idx2 = np.intersect1d(idx1, idx_s)\n",
    "\n",
    "                    self.data_frame = self.data_frame.drop(idx2)\n",
    "                except:\n",
    "                    pass\n",
    "        \n",
    "        # Update the past selected indices\n",
    "        self.past_selected = self.selected_indices\n",
    "        \n",
    "        model = pandasModel(self.data_frame, self.dc)\n",
    "        \n",
    "        self.table.setModel(model)\n",
    "       \n",
    "        self.table.setSortingEnabled(True)\n",
    "        self.table.setShowGrid(False)  \n",
    "    \n",
    "    def runDataStats (self, data_i, comp_i):\n",
    "        '''\n",
    "        Runs statistics for the component comp_i of data set data_i\n",
    "        '''\n",
    "\n",
    "        subset_label = \"--\"\n",
    "        data_label = dc[data_i].label   \n",
    "        comp_label = self.dc[data_i].components[comp_i].label # add to the name array to build the table\n",
    "        \n",
    "        # Build the cache key\n",
    "        cache_key = subset_label + data_label + comp_label\n",
    "        \n",
    "        # See if the values have already been cached\n",
    "        try:\n",
    "            column_data = self.cache_stash[cache_key]\n",
    "        \n",
    "        except:         \n",
    "        # Find the stat values\n",
    "        # Save the data in the cache \n",
    "            mean_val = self.dc[data_i].compute_statistic('mean', self.dc[data_i].components[comp_i])\n",
    "            median_val = self.dc[data_i].compute_statistic('median', self.dc[data_i].components[comp_i])     \n",
    "            min_val = self.dc[data_i].compute_statistic('minimum', self.dc[data_i].components[comp_i])     \n",
    "            max_val = self.dc[data_i].compute_statistic('maximum', self.dc[data_i].components[comp_i])    \n",
    "            sum_val = self.dc[data_i].compute_statistic('sum', self.dc[data_i].components[comp_i])\n",
    "\n",
    "            column_data = np.asarray([[subset_label], [data_label], [comp_label], [mean_val], [median_val], [min_val], [max_val], [sum_val]]).transpose()\n",
    "            \n",
    "            self.cache_stash[cache_key] = column_data\n",
    "        \n",
    "        # Save the accurate data in self.data_accurate\n",
    "        column_df = pd.DataFrame(column_data, columns = self.headings)\n",
    "        self.data_accurate = self.data_accurate.append(column_df, ignore_index = True)        \n",
    "\n",
    "        if self.isSci:\n",
    "            # Format in scientific notation\n",
    "            string = \"%.\" + str(self.num_sigs) + 'E'\n",
    "        else:\n",
    "            # Format in standard notation\n",
    "            string = \"%.\" + str(self.num_sigs) + 'F'             \n",
    "\n",
    "        mean_val = string % Decimal(column_data[0][3])\n",
    "        median_val = string % Decimal(column_data[0][4])\n",
    "        min_val = string % Decimal(column_data[0][5])\n",
    "        max_val = string % Decimal(column_data[0][6])\n",
    "        sum_val = string % Decimal(column_data[0][7])            \n",
    "    #             mean_val = float(Decimal(column_data[0][3]) * Decimal(1))\n",
    "    #             median_val = float(Decimal(column_data[0][4]) * Decimal(1))\n",
    "    #             min_val = float(Decimal(column_data[0][5]) * Decimal(1))\n",
    "    #             max_val = float(Decimal(column_data[0][6]) * Decimal(1))\n",
    "    #             sum_val = float(Decimal(column_data[0][7]) * Decimal(1))\n",
    "\n",
    "            # Create the column data array and append it to the data frame\n",
    "        column_data = np.asarray([[subset_label], [data_label], [comp_label], [mean_val], [median_val], [min_val], [max_val], [sum_val]]).transpose()\n",
    "        column_df = pd.DataFrame(column_data, columns = self.headings)\n",
    "        self.data_frame = self.data_frame.append(column_df, ignore_index = True)\n",
    "    \n",
    "    def runSubsetStats (self, subset_i, data_i, comp_i):\n",
    "        '''\n",
    "        Runs statistics for the subset subset_i with respect to the component comp_i of data set data_i\n",
    "        '''\n",
    "\n",
    "        subset_label = dc[data_i].subsets[subset_i].label\n",
    "        data_label = dc[data_i].label   \n",
    "        comp_label = self.dc[data_i].components[comp_i].label # add to the name array to build the table\n",
    "        \n",
    "        # Build the cache key\n",
    "        cache_key = subset_label + data_label + comp_label\n",
    "        \n",
    "        # See if the statistics are already in the cache\n",
    "        try:\n",
    "            column_data = self.cache_stash[cache_key]\n",
    "        \n",
    "        # Find the stats if not in the cache\n",
    "        # Save in the cache\n",
    "        \n",
    "        except:\n",
    "            mean_val = self.dc[data_i].compute_statistic('mean', self.dc[data_i].subsets[subset_i].components[comp_i], subset_state=self.dc[data_i].subsets[subset_i].subset_state)\n",
    "            median_val = self.dc[data_i].compute_statistic('median', self.dc[data_i].subsets[subset_i].components[comp_i], subset_state=self.dc.subset_groups[subset_i].subset_state)       \n",
    "            min_val = self.dc[data_i].compute_statistic('minimum', self.dc[data_i].subsets[subset_i].components[comp_i], subset_state=self.dc.subset_groups[subset_i].subset_state)       \n",
    "            max_val = self.dc[data_i].compute_statistic('maximum', self.dc[data_i].subsets[subset_i].components[comp_i], subset_state=self.dc.subset_groups[subset_i].subset_state)      \n",
    "            sum_val = self.dc[data_i].compute_statistic('sum', self.dc[data_i].subsets[subset_i].components[comp_i], subset_state=self.dc.subset_groups[subset_i].subset_state) \n",
    "\n",
    "            column_data = np.asarray([[subset_label], [data_label], [comp_label], [mean_val], [median_val], [min_val], [max_val], [sum_val]]).transpose()\n",
    "\n",
    "            self.cache_stash[cache_key] = column_data\n",
    "        \n",
    "        # Save the data in self.data_accurate\n",
    "        column_df = pd.DataFrame(column_data, columns = self.headings)\n",
    "        self.data_accurate = self.data_accurate.append(column_df, ignore_index = True)        \n",
    "        \n",
    "        if self.isSci:\n",
    "            # Format in scientific notation\n",
    "            string = \"%.\" + str(self.num_sigs) + 'E'\n",
    "        else:\n",
    "            # Format in standard notation\n",
    "            string = \"%.\" + str(self.num_sigs) + 'F'            \n",
    "            \n",
    "        mean_val = string % Decimal(column_data[0][3])\n",
    "        median_val = string % Decimal(column_data[0][4])\n",
    "        min_val = string % Decimal(column_data[0][5])\n",
    "        max_val = string % Decimal(column_data[0][6])\n",
    "        sum_val = string % Decimal(column_data[0][7])\n",
    "            \n",
    "#             mean_val = float(Decimal(column_data[0][3]) * Decimal(1))\n",
    "#             median_val = float(Decimal(column_data[0][4]) * Decimal(1))\n",
    "#             min_val = float(Decimal(column_data[0][5]) * Decimal(1))\n",
    "#             max_val = float(Decimal(column_data[0][6]) * Decimal(1))\n",
    "#             sum_val = float(Decimal(column_data[0][7]) * Decimal(1))\n",
    "        \n",
    "        # Create the column data array and append it to the data frame\n",
    "        column_data = np.asarray([[subset_label], [data_label], [comp_label], [mean_val], [median_val], [min_val], [max_val], [sum_val]]).transpose()\n",
    "        column_df = pd.DataFrame(column_data, columns = self.headings)\n",
    "        self.data_frame = self.data_frame.append(column_df, ignore_index = True)    \n",
    "    \n",
    "    def sigchange(self, i):\n",
    "        # Set the number of significant figures according to what the user selects\n",
    "        getcontext().prec = i\n",
    "        self.num_sigs = i\n",
    "        \n",
    "        # Retrospectively change the number of significant figures in the table\n",
    "        \n",
    "        data_labels = self.data_frame['Dataset']\n",
    "        comp_labels = self.data_frame['Component']\n",
    "        subset_labels = self.data_frame['Subset']\n",
    "        \n",
    "        mean_vals = []\n",
    "        median_vals = []\n",
    "        min_vals = []\n",
    "        max_vals = []\n",
    "        sum_vals = []\n",
    "        \n",
    "        if self.isSci:\n",
    "            string = \"%.\" + str(self.num_sigs) + 'E'\n",
    "        else:\n",
    "            string = \"%.\" + str(self.num_sigs) + 'F'    \n",
    "    \n",
    "        # Get the values from the self.data_accurate array and append them\n",
    "        for i in range (0, len(self.data_frame)):\n",
    "            # Get the correct index\n",
    "                \n",
    "            component = self.data_frame['Component'][i]\n",
    "            dataset = self.data_frame['Dataset'][i]\n",
    "            subset = self.data_frame['Subset'][i]\n",
    "                \n",
    "            idx_c = np.where(component == self.data_accurate['Component'])\n",
    "            idx_d = np.where(dataset == self.data_accurate['Dataset'])\n",
    "            idx_s = np.where(subset == self.data_accurate['Subset'])\n",
    "            idx1 = np.intersect1d(idx_c, idx_d)\n",
    "            idx2 = np.intersect1d(idx1, idx_s)[0] \n",
    "                \n",
    "            mean_vals.append(string % Decimal(self.data_accurate['Mean'][idx2]))\n",
    "            median_vals.append(string % Decimal(self.data_accurate['Median'][idx2]))\n",
    "            min_vals.append(string % Decimal(self.data_accurate['Minimum'][idx2]))\n",
    "            max_vals.append(string % Decimal(self.data_accurate['Maximum'][idx2]))\n",
    "            sum_vals.append(string % Decimal(self.data_accurate['Sum'][idx2]))               \n",
    "                \n",
    "#                 mean_vals.append(float(Decimal(self.data_accurate['Mean'][i]) * Decimal(1)))\n",
    "#                 median_vals.append(float(Decimal(self.data_accurate['Median'][i]) * Decimal(1)))\n",
    "#                 min_vals.append(float(Decimal(self.data_accurate['Minimum'][i]) * Decimal(1)))\n",
    "#                 max_vals.append(float(Decimal(self.data_accurate['Maximum'][i]) * Decimal(1)))\n",
    "#                 sum_vals.append(float(Decimal(self.data_accurate['Sum'][i]) * Decimal(1)))\n",
    "            \n",
    "        column_data = np.asarray([subset_labels, data_labels, comp_labels, mean_vals, median_vals, min_vals, max_vals, sum_vals]).transpose()\n",
    "        \n",
    "        self.data_frame = pd.DataFrame(column_data, columns=self.headings)\n",
    "        model = pandasModel(self.data_frame, self.dc)\n",
    "        self.table.setModel(model)\n",
    "        self.table.setSortingEnabled(True)\n",
    "        self.table.setShowGrid(False)        \n",
    "        \n",
    "    def expandClicked(self):\n",
    "        if self.expand_data.text() == \"Expand all data and subsets\":\n",
    "            self.treeview.expandAll()\n",
    "            self.expand_data.setText(\"Collapse all data and subsets\")\n",
    "        else:\n",
    "            self.treeview.collapseAll()\n",
    "            self.expand_data.setText(\"Expand all data and subsets\")\n",
    "        \n",
    "    def allClicked(self):\n",
    "        # Select all components of the treeview if checked and fill the table with newly checked items\n",
    "        # Does not deselect if user unclicks it\n",
    "        \n",
    "        self.treeview.expandAll()\n",
    "        self.expand_data.setText(\"Collapse all data and subsets\")\n",
    "        \n",
    "        original_idx = self.treeview.selectionModel().selectedRows()\n",
    "\n",
    "        self.treeview.selectAll()\n",
    "        end_idx=self.treeview.selectionModel().selectedRows()\n",
    "        for index in end_idx:\n",
    "            if index not in original_idx:\n",
    "                # Check to see if the clicked item is a subset component or a data component\n",
    "                # Get correct index for either view\n",
    "                if not self.component_mode:\n",
    "                    if index.parent().parent().parent().row() == -1:\n",
    "                        # Whole data sets\n",
    "                        data_i = index.parent().row()\n",
    "                        comp_i = index.row()\n",
    "                        subset_i = -1\n",
    "                    else:\n",
    "                        # Subsets\n",
    "                        data_i = index.parent().row()\n",
    "                        comp_i = index.row()\n",
    "                        subset_i = index.parent().parent().row()          \n",
    "                else:\n",
    "                    data_i = index.parent().parent().row()\n",
    "                    comp_i = index.parent().row()\n",
    "                    subset_i = index.row() - 1\n",
    "                \n",
    "                is_subset = index.parent().parent().parent().row() == 1 or (self.switch_mode.text() == 'Sort tree by subsets' and subset_i != -1)\n",
    "                \n",
    "                if is_subset:\n",
    "                    try:\n",
    "                        self.runSubsetStats(subset_i, data_i, comp_i)\n",
    "                    except:\n",
    "                        print(\"subset stats could not be run for: subset: \", subset_i, \"data: \", data_i, \"comp: \", comp_i)\n",
    "                else:\n",
    "                    try:\n",
    "                        self.runDataStats(data_i, comp_i)\n",
    "                    except:\n",
    "                        print(\"data stats could not be run for data: \", data_i, \"component: \", comp_i)\n",
    "        \n",
    "        # Set the table to display the correct data frame\n",
    "        model = pandasModel(self.data_frame, self.dc)\n",
    "        self.table.setModel(model)\n",
    "        self.table.setSortingEnabled(True)\n",
    "        self.table.setShowGrid(False) \n",
    "\n",
    "    def noneClicked(self):\n",
    "        self.treeview.clearSelection()\n",
    "        self.data_frame = pd.DataFrame(columns = self.headings)\n",
    "        model = pandasModel(self.data_frame, self.dc)\n",
    "        self.table.setModel(model)\n",
    "        self.table.setSortingEnabled(True)\n",
    "        self.table.setShowGrid(False)\n",
    "        \n",
    "    def exportToFile(self):\n",
    "        file_name,fltr=compat.getsavefilename(caption=\"Choose an output filename\")\n",
    "        \n",
    "        try:\n",
    "            self.data_frame.to_csv(str(file_name), index=False)\n",
    "        except:\n",
    "            print(\"passed\")\n",
    "            pass\n",
    "        \n",
    "    def switchMode(self):\n",
    "        # if the user clicks to sort by components, change the text to \"sort by subsets\" and sort tree by components\n",
    "        if self.switch_mode.text() == 'Sort tree by components':\n",
    "            self.sortByComponents()\n",
    "            self.switch_mode.setText('Sort tree by subsets')\n",
    "        # otherwise the user wants to sort by subsets, change text to \"sort by components\" and sort tree by subsets\n",
    "        else:\n",
    "            self.sortBySubsets()\n",
    "            self.switch_mode.setText('Sort tree by components')\n",
    "  \n",
    "    def sizeHint(self):\n",
    "        return QSize(600, 800)\n",
    "    \n",
    "    def sortBySubsets(self):\n",
    "        '''\n",
    "        Sorts the treeview by subsets- Dataset then subset then component.\n",
    "        What we originally had as the default\n",
    "        '''\n",
    "        # Set to not component mode\n",
    "        self.component_mode = False\n",
    "        \n",
    "        # Clear the data_accurate\n",
    "        self.data_accurate = pd.DataFrame(columns=self.headings)      \n",
    "        \n",
    "        # Save the selected rows from the component view\n",
    "        try:\n",
    "            selected = dict()\n",
    "#             print(\"in sort by subsets: \")\n",
    "            for i in range(0, len(self.selected_indices)):\n",
    "                item = self.model_components.itemFromIndex(self.selected_indices[i])\n",
    "                if item.row() != 0:\n",
    "                    key = item.text() + \" (\" + item.parent().parent().text() + \")\"+ item.parent().text()\n",
    "                    selected[key] = item.index()\n",
    "#                     print(\"item.row() != 0: \", key, item.index())\n",
    "                else:\n",
    "                    key = item.text() + item.parent().text()\n",
    "                    selected[key] = item.index()\n",
    "#                     print(\"else: \", key, item.index())\n",
    "                \n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "        # Clear the selection\n",
    "        self.treeview.clearSelection()\n",
    "        \n",
    "        # Set Expand/collapse button to \"expand all\"\n",
    "        self.expand_data.setText(\"Expand all data and subsets\")       \n",
    "        \n",
    "        #Allow the user to select multiple rows at a time \n",
    "        self.selection_model = QAbstractItemView.MultiSelection\n",
    "        self.treeview.setSelectionMode(self.selection_model)\n",
    "        \n",
    "        # See if the model already exists instead of regenerating\n",
    "        try:\n",
    "            self.treeview.setModel(self.model_subsets)\n",
    "        \n",
    "        except:\n",
    "            self.model_subsets = QStandardItemModel()\n",
    "            self.model_subsets.setHorizontalHeaderLabels([''])\n",
    "\n",
    "            self.treeview.setModel(self.model_subsets)\n",
    "            self.treeview.setUniformRowHeights(True)\n",
    "\n",
    "            # populate the tree\n",
    "            # Make all the datasets be parents, and make it so they are not selectable\n",
    "            parent_data = QStandardItem('{}'.format('Data'))\n",
    "            parent_data.setEditable(False)\n",
    "            parent_data.setSelectable(False)\n",
    "\n",
    "            for i in range(0, len(self.dc)):\n",
    "                parent = QStandardItem('{}'.format(self.dc.labels[i]))\n",
    "                parent.setIcon(helpers.layer_icon(self.dc[i]))\n",
    "                parent.setEditable(False)\n",
    "                parent.setSelectable(False)\n",
    "\n",
    "                # Make all the data components be children, nested under their parent\n",
    "                for j in range(0,len(self.dc[i].components)):\n",
    "                    child=QStandardItem('{}'.format(str(self.dc[i].components[j])))\n",
    "                    child.setEditable(False)\n",
    "                    \n",
    "                    # Add to the subset_dict\n",
    "                    key = self.dc[i].label + self.dc[i].components[j].label + \"All data-\" + self.dc[i].label\n",
    "                    self.subset_dict[key] = child.index()\n",
    "                    \n",
    "                    parent.appendRow(child)\n",
    "\n",
    "                parent_data.appendRow(parent)\n",
    "\n",
    "                #Add the parents with their children to the QStandardItemModel\n",
    "            self.model_subsets.appendRow(parent_data)\n",
    "\n",
    "            parent_subset = QStandardItem('{}'.format('Subsets')) \n",
    "            parent_subset.setEditable(False)\n",
    "            parent_subset.setSelectable(False)\n",
    "\n",
    "            # Set up the subsets as Subsets > choose subset > choose data set > choose component\n",
    "\n",
    "            for j in range(0, len(self.dc.subset_groups)):\n",
    "                grandparent = QStandardItem('{}'.format(self.dc.subset_groups[j].label))\n",
    "                grandparent.setIcon(helpers.layer_icon(self.dc.subset_groups[j]))\n",
    "\n",
    "                grandparent.setEditable(False)\n",
    "                grandparent.setSelectable(False)\n",
    "\n",
    "                for i in range(0, len(self.dc)):\n",
    "                    parent = QStandardItem('{}'.format(self.dc.subset_groups[j].label) + ' (' + '{}'.format(self.dc[i].label) + ')')\n",
    "\n",
    "                    # Set up the circles\n",
    "                    parent.setIcon(helpers.layer_icon(self.dc.subset_groups[j]))\n",
    "                    parent.setEditable(False)\n",
    "                    parent.setSelectable(False)\n",
    "\n",
    "                    try:\n",
    "                        self.dc[i].compute_statistic('mean', self.dc[i].subsets[j].components[0], subset_state=self.dc[i].subsets[j].subset_state)\n",
    "\n",
    "                    except:\n",
    "                        parent.setForeground(QtGui.QBrush(Qt.gray))\n",
    "\n",
    "                    for k in range(0, len(self.dc[i].components)):\n",
    "\n",
    "                        child = QStandardItem('{}'.format(str(self.dc[i].components[k])))\n",
    "                        child.setEditable(False)\n",
    "                        \n",
    "                        # Update the dict to keep track of row indices\n",
    "                        key = self.dc[i].label + self.dc[i].components[k].label + self.dc[i].subsets[j].label\n",
    "                        self.subset_dict[key] = child.index()\n",
    "                        \n",
    "                        parent.appendRow(child)\n",
    "\n",
    "                        # Make gray and unselectable components that aren't defined for a subset\n",
    "                        try:\n",
    "                            self.dc[i].compute_statistic('mean', self.dc[i].subsets[j].components[k], subset_state=self.dc[i].subsets[j].subset_state)\n",
    "\n",
    "                        except:\n",
    "#                             print(\"Glue has raised an Incompatible Attribute error on this component. Let's do this instead.\")\n",
    "                            child.setEditable(False)\n",
    "                            child.setSelectable(False)\n",
    "                            child.setForeground(QtGui.QBrush(Qt.gray))\n",
    "\n",
    "                    grandparent.appendRow(parent) \n",
    "                parent_subset.appendRow(grandparent)\n",
    "            self.model_subsets.appendRow(parent_subset)\n",
    "        \n",
    "            # Fill out the dict now that the indices are connected to the QStandardItemModel\n",
    "            \n",
    "            # Full datasets\n",
    "            for i in range(0, parent_data.rowCount()):\n",
    "                for j in range(0, parent_data.child(i).rowCount()):\n",
    "                    key = \"All data (\" + parent_data.child(i).text() + \")\"+ parent_data.child(i).child(j).text()\n",
    "                    self.subset_dict[key] = parent_data.child(i).child(j).index()\n",
    "            \n",
    "            # Subsets\n",
    "            for i in range(0, parent_subset.rowCount()):\n",
    "                for j in range(0, parent_subset.child(i).rowCount()):\n",
    "                    for k in range(0, parent_subset.child(i).child(j).rowCount()):\n",
    "                        key = parent_subset.child(i).child(j).text() + parent_subset.child(i).child(j).child(k).text()\n",
    "                        self.subset_dict[key] = parent_subset.child(i).child(j).child(k).index()\n",
    "        \n",
    "        self.treeview.setUniformRowHeights(True)\n",
    "        \n",
    "        selection_model = QItemSelectionModel(self.model_subsets)\n",
    "        self.treeview.setSelectionModel(selection_model)\n",
    "        selection_model.selectionChanged.connect(self.myPressedEvent)\n",
    "\n",
    "        # Clear the table \n",
    "        self.data_frame = pd.DataFrame(columns = self.headings)\n",
    "        model = pandasModel(self.data_frame, self.dc)\n",
    "        self.table.setModel(model)\n",
    "        self.table.setSortingEnabled(True)\n",
    "        self.table.setShowGrid(False)\n",
    "        \n",
    "        # Select rows that should be selected\n",
    "        \n",
    "        sel_mod = self.treeview.selectionModel()\n",
    "        \n",
    "        for i in range(0, len(selected)):\n",
    "            key = list(selected.keys())[i]\n",
    "            index = self.subset_dict[key]\n",
    "            self.treeview.setCurrentIndex(index)\n",
    "    \n",
    "        self.treeview.setSelectionModel(sel_mod)\n",
    "        \n",
    "        # Update the past_selected and selected_indices\n",
    "        self.past_selected = self.treeview.selectionModel().selectedRows()\n",
    "        self.selected_indices = self.treeview.selectionModel().selectedRows()\n",
    "    \n",
    "    def sortByComponents(self):\n",
    "        '''\n",
    "        Sorts the treeview by components- Dataset then component then subsets\n",
    "        '''  \n",
    "        # Set component_mode to true\n",
    "        self.component_mode = True\n",
    "        \n",
    "        # Clear the data_accurate\n",
    "        self.data_accurate = pd.DataFrame(columns=self.headings)\n",
    "        \n",
    "        # Save the selected rows from the subset view if applicable\n",
    "        try:\n",
    "            selected = dict()\n",
    "\n",
    "            for i in range(0, len(self.selected_indices)):\n",
    "                item = self.model_subsets.itemFromIndex(self.selected_indices[i])\n",
    "                if item.parent().parent().text() == \"Data\":\n",
    "                    key =  \"All data (\" + item.parent().text() + \")\" + item.text()\n",
    "                    selected[key] = item.index()\n",
    "                else:\n",
    "                    key = item.parent().text() + item.text()\n",
    "                    selected[key] = item.index()\n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "        # Clear the selection\n",
    "        self.treeview.clearSelection()\n",
    "        \n",
    "        # Set Expand/collapse button to \"expand all\"\n",
    "        self.expand_data.setText(\"Expand all data and subsets\")\n",
    "        \n",
    "        self.selection_model = QAbstractItemView.MultiSelection\n",
    "        self.treeview.setSelectionMode(self.selection_model)\n",
    "        \n",
    "        # See if the model already exists\n",
    "        try:\n",
    "            self.treeview.setModel(self.model_components)\n",
    "            \n",
    "        except: \n",
    "        \n",
    "            self.model_components = QStandardItemModel()\n",
    "            self.model_components.setHorizontalHeaderLabels([''])\n",
    "\n",
    "            self.treeview.setModel(self.model_components)\n",
    "            self.treeview.setUniformRowHeights(True)\n",
    "    \n",
    "            # populate the tree\n",
    "            # Make all the datasets be parents, and make it so they are not selectable\n",
    "        \n",
    "            for i in range(0,len(dc)):\n",
    "                grandparent = QStandardItem('{}'.format(self.dc.labels[i]))\n",
    "                grandparent.setIcon(helpers.layer_icon(self.dc[i]))\n",
    "                grandparent.setEditable(False)\n",
    "                grandparent.setSelectable(False)\n",
    "            \n",
    "                # Make all the data components be children, nested under their parent\n",
    "                for k in range(0,len(self.dc[i].components)):\n",
    "                    parent=QStandardItem('{}'.format(str(self.dc[i].components[k])))\n",
    "                    parent.setEditable(False)\n",
    "                    parent.setSelectable(False)\n",
    "                \n",
    "                    child = QStandardItem('{}'.format('All data (' + self.dc.labels[i] + ')'))\n",
    "                    child.setIcon(helpers.layer_icon(self.dc[i]))\n",
    "                    child.setEditable(False)\n",
    "                    \n",
    "                    parent.appendRow(child)\n",
    "                \n",
    "                    for j in range(0, len(self.dc.subset_groups)):\n",
    "                        child = QStandardItem('{}'.format(self.dc.subset_groups[j].label))\n",
    "                        child.setEditable(False)\n",
    "                        child.setIcon(helpers.layer_icon(self.dc.subset_groups[j]))\n",
    "                        \n",
    "                        try:\n",
    "                            self.dc[i].compute_statistic('mean', self.dc[i].subsets[j].components[k], subset_state=self.dc[i].subsets[j].subset_state)\n",
    "\n",
    "                        except:\n",
    "#                             print(\"Glue has raised an Incompatible Attribute error on this component. Let's do this instead.\")\n",
    "                            child.setEditable(False)\n",
    "                            child.setSelectable(False)\n",
    "                            child.setForeground(QtGui.QBrush(Qt.gray)) \n",
    "\n",
    "                        parent.appendRow(child)\n",
    "                    grandparent.appendRow(parent)\n",
    "                self.model_components.appendRow(grandparent)\n",
    "                \n",
    "                # Fill out the dict now that the indices are connected to the QStandardItemModel\n",
    "                for i in range(0, grandparent.rowCount()):\n",
    "                    for j in range(0, grandparent.child(i).rowCount()):\n",
    "                        if grandparent.child(i).child(j).row() == 0:\n",
    "                            key = grandparent.child(i).child(j).text() + grandparent.child(i).text()\n",
    "                            self.component_dict[key] = grandparent.child(i).child(j).index()\n",
    "                        else:\n",
    "                            key = grandparent.child(i).child(j).text() + \" (\" + grandparent.text() + \")\" + grandparent.child(i).text()\n",
    "                            self.component_dict[key] = grandparent.child(i).child(j).index()\n",
    "            \n",
    "        self.treeview.setUniformRowHeights(True)\n",
    "        \n",
    "        selection_model = QItemSelectionModel(self.model_components)\n",
    "        self.treeview.setSelectionModel(selection_model)\n",
    "        selection_model.selectionChanged.connect(self.myPressedEvent)\n",
    " \n",
    "        # Clear the table \n",
    "        self.data_frame = pd.DataFrame(columns = self.headings)\n",
    "        model = pandasModel(self.data_frame, self.dc)\n",
    "        self.table.setModel(model)\n",
    "        self.table.setSortingEnabled(True)\n",
    "        self.table.setShowGrid(False)\n",
    "\n",
    "        # Select the rows that should be selected\n",
    "\n",
    "        sel_mod = self.treeview.selectionModel()\n",
    "    \n",
    "        for i in range(0, len(selected)):\n",
    "            key = list(selected.keys())[i]\n",
    "            index = self.component_dict[key]\n",
    "            self.treeview.setCurrentIndex(index)\n",
    "    \n",
    "        self.treeview.setSelectionModel(sel_mod)\n",
    "        \n",
    "        # Update the past_selected and selected_indices\n",
    "        self.past_selected = self.treeview.selectionModel().selectedRows() \n",
    "        self.selected_indices = self.treeview.selectionModel().selectedRows()\n",
    "            \n",
    "    def notation(self):\n",
    "        data_labels = self.data_frame['Dataset']\n",
    "        comp_labels = self.data_frame['Component']\n",
    "        subset_labels = self.data_frame['Subset']\n",
    "        \n",
    "        mean_vals = []\n",
    "        median_vals = []\n",
    "        min_vals = []\n",
    "        max_vals = []\n",
    "        sum_vals = []\n",
    "        \n",
    "        if self.stan_notation.isChecked():\n",
    "            self.isSci = False\n",
    "            string = \"%.\" + str(self.num_sigs) + 'F'\n",
    "        else:\n",
    "            self.isSci = True\n",
    "            string = \"%.\" + str(self.num_sigs) + 'E'    \n",
    "            \n",
    "        for i in range(0, len(self.data_frame)):\n",
    "            component = self.data_frame['Component'][i]\n",
    "            dataset = self.data_frame['Dataset'][i]\n",
    "            subset = self.data_frame['Subset'][i]\n",
    "                \n",
    "            idx_c = np.where(component == self.data_accurate['Component'])\n",
    "            idx_d = np.where(dataset == self.data_accurate['Dataset'])\n",
    "            idx_s = np.where(subset == self.data_accurate['Subset'])\n",
    "            idx1 = np.intersect1d(idx_c, idx_d)\n",
    "            idx2 = np.intersect1d(idx1, idx_s)[0] \n",
    "                \n",
    "            mean_vals.append(string % Decimal(self.data_accurate['Mean'][idx2]))\n",
    "            median_vals.append(string % Decimal(self.data_accurate['Median'][idx2]))\n",
    "            min_vals.append(string % Decimal(self.data_accurate['Minimum'][idx2]))\n",
    "            max_vals.append(string % Decimal(self.data_accurate['Maximum'][idx2]))\n",
    "            sum_vals.append(string % Decimal(self.data_accurate['Sum'][idx2])) \n",
    "            \n",
    "        column_data = np.asarray([subset_labels, data_labels, comp_labels, mean_vals, median_vals, min_vals, max_vals, sum_vals]).transpose()\n",
    "        self.data_frame = pd.DataFrame(column_data, columns=self.headings)\n",
    "        model = pandasModel(self.data_frame, self.dc)\n",
    "        self.table.setModel(model)\n",
    "        self.table.setSortingEnabled(True)\n",
    "        self.table.setShowGrid(False) \n",
    "            \n",
    "app = QApplication.instance()\n",
    "if app is None:\n",
    "    app = QApplication(sys.argv)\n",
    "else:\n",
    "    print('QApplication instance already exists: %s' % str(app))\n",
    "ex = StatsGui(dc)\n",
    "ex.show()\n",
    "sys.exit(app.exec_())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}