def move_itemsAcross(self, source, modifiers):
""" Create new tree items and populate the target tree. Originally made
for moving items from fileDataTree to workingDataTree, but then modified
to copy items when the move is internal in workingDataTree and Ctrl is
pressed.
"""
if (source==self.ui.workingDataTree) and (modifiers==QtCore.Qt.ControlModifier):
# Copy internally
#print 'copying'
targetItems = []
for item in self.copyItems:
i = h5Item([str(item.text(0))])
i.data = item.data
targetItems.append(i)
parentIndex = self.ui.workingDataTree.indexFromItem(self.dragTargetParent)
for row in np.arange(0, len(self.copyItems)):
index = self.ui.workingDataTree.model().index(self.dragTargetRow+row, 0, parentIndex)
temp_item = self.ui.workingDataTree.itemFromIndex(QtCore.QModelIndex(index))
sip.delete(temp_item)
if parentIndex.isValid():
self.make_nameUnique(self.dragTargetParent, targetItems[row], targetItems[row].text(0))
self.dragTargetParent.insertChild(index.row(), targetItems[row])
originalParentWidget = self.copyItems[row]
h5.populate_h5copyItems(self, originalParentWidget, targetItems[row])
else:
self.make_nameUnique(self.ui.workingDataTree.invisibleRootItem(), targetItems[row], targetItems[row].text(0))
self.ui.workingDataTree.insertTopLevelItem(index.row(), targetItems[row])
originalParentWidget = self.copyItems[row]
h5.populate_h5copyItems(self, originalParentWidget, targetItems[row])
elif source==self.ui.workingDataTree:
pass
else:
# Move across
#print 'moving'
targetItems = []
for item in self.dragItems:
i = h5Item([str(item[1])])
i.path = item[0]
i.listIndex = item[2]
i.originalIndex = item[3]
i.data = item[4]
i.attrs = item[5]
#item = i[0]
#item.originalIndex = i[1]
targetItems.append(i)
parentIndex = self.ui.workingDataTree.indexFromItem(self.dragTargetParent)
for row in np.arange(0, len(self.dragItems)):
index = self.ui.workingDataTree.model().index(self.dragTargetRow+row, 0, parentIndex)
temp_item = self.ui.workingDataTree.itemFromIndex(QtCore.QModelIndex(index))
sip.delete(temp_item)
if parentIndex.isValid():
self.make_nameUnique(self.dragTargetParent, targetItems[row], targetItems[row].text(0))
self.dragTargetParent.insertChild(index.row(), targetItems[row])
originalParentWidget = self.ui.fileDataTree.itemFromIndex(QtCore.QModelIndex(targetItems[row].originalIndex))
h5.populate_h5dragItems(self, originalParentWidget, targetItems[row])
else:
self.make_nameUnique(self.ui.workingDataTree.invisibleRootItem(), targetItems[row], targetItems[row].text(0))
self.ui.workingDataTree.insertTopLevelItem(index.row(), targetItems[row])
originalParentWidget = self.ui.fileDataTree.itemFromIndex(QtCore.QModelIndex(targetItems[row].originalIndex))
h5.populate_h5dragItems(self, originalParentWidget, targetItems[row])
def add_treeGroup(browser, tree, level, name):
if level=='root':
item = h5Item([name])
parentWidget = browser.ui.workingDataTree.invisibleRootItem()
browser.make_nameUnique(parentWidget, item, name)
tree.addTopLevelItem(item)
elif level=='child':
item = h5Item([name])
parentWidget = tree.currentItem()
browser.make_nameUnique(parentWidget, item, name)
parentWidget.addChild(item)
def add_treeGroup(browser, tree, level, name):
if level=='root':
item = h5Item([name])
parentWidget = browser.ui.workingDataTree.invisibleRootItem()
browser.make_nameUnique(parentWidget, item, name)
tree.addTopLevelItem(item)
elif level=='child':
item = h5Item([name])
parentWidget = tree.currentItem()
browser.make_nameUnique(parentWidget, item, name)
parentWidget.addChild(item)
def move_itemsAcross(self):
""" Create new tree items and populate the target tree
"""
targetItems = []
for item in self.dragItems:
i = h5Item([str(item[1])])
i.path = item[0]
i.listIndex = item[2]
i.originalIndex = item[3]
targetItems.append(i)
parentIndex = self.ui.workingDataTree.indexFromItem(self.dragTargetParent)
for row in np.arange(0, len(self.dragItems)):
index = self.ui.workingDataTree.model().index(self.dragTargetRow+row, 0, parentIndex)
temp_item = self.ui.workingDataTree.itemFromIndex(QtCore.QModelIndex(index))
sip.delete(temp_item)
if parentIndex.isValid():
self.make_nameUnique(self.dragTargetParent, targetItems[row], targetItems[row].text(0))
self.dragTargetParent.insertChild(index.row(), targetItems[row])
originalParentWidget = self.ui.fileDataTree.itemFromIndex(QtCore.QModelIndex(targetItems[row].originalIndex))
h5.populate_h5dragItems(self, originalParentWidget, targetItems[row])
else:
self.make_nameUnique(self.ui.workingDataTree.invisibleRootItem(), targetItems[row], targetItems[row].text(0))
self.ui.workingDataTree.insertTopLevelItem(index.row(), targetItems[row])
originalParentWidget = self.ui.fileDataTree.itemFromIndex(QtCore.QModelIndex(targetItems[row].originalIndex))
h5.populate_h5dragItems(self, originalParentWidget, targetItems[row])
def make_h5item(name, data, attrs):
""" Makes a new h5item for general use
"""
item = h5Item([name])
item.data = data
item.attrs = attrs
return item
def make_h5item(name, data, attrs):
""" Makes a new h5item for general use
"""
item = h5Item([name])
item.data = data
item.attrs = attrs
return item
def populate_h5dragItems(browser, originalParentWidget, parentWidget):
if originalParentWidget.childCount() > 0:
for c in range(originalParentWidget.childCount()):
child = originalParentWidget.child(c)
#itemName = make_nameUnique(parentWidget, child.text(0))
i = h5Item([str(child.text(0))])
i.path = child.path
i.group = child.group
i.channel = child.channel
parentWidget.addChild(i)
if child.childCount() > 0:
populate_h5dragItems(browser, child, i)
else:
set_attrs(child, i)
i.listIndex = len(browser.ui.workingDataTree.dataItems)
i.data = get_dataFromFile(browser, i)
browser.ui.workingDataTree.dataItems.append(i)
# For transferring datasets directly
else:
set_attrs(originalParentWidget, parentWidget)
parentWidget.path = originalParentWidget.path
parentWidget.listIndex = len(browser.ui.workingDataTree.dataItems)
#browser.ui.workingDataTree.data.append(browser.db[originalParentWidget.path][:])
parentWidget.data = browser.db[originalParentWidget.path][:]
browser.ui.workingDataTree.dataItems.append(parentWidget)
def populate_h5dragItems(browser, originalParentWidget, parentWidget):
if originalParentWidget.childCount()>0:
for c in range(originalParentWidget.childCount()):
child = originalParentWidget.child(c)
#itemName = make_nameUnique(parentWidget, child.text(0))
i = h5Item([str(child.text(0))])
i.path = child.path
i.group = child.group
i.channel = child.channel
parentWidget.addChild(i)
if child.childCount()>0:
populate_h5dragItems(browser, child, i)
else:
set_attrs(child, i)
i.listIndex = len(browser.ui.workingDataTree.dataItems)
i.data = get_dataFromFile(browser, i)
browser.ui.workingDataTree.dataItems.append(i)
# For transferring datasets directly
else:
set_attrs(originalParentWidget, parentWidget)
parentWidget.path = originalParentWidget.path
parentWidget.listIndex = len(browser.ui.workingDataTree.dataItems)
#browser.ui.workingDataTree.data.append(browser.db[originalParentWidget.path][:])
parentWidget.data = browser.db[originalParentWidget.path][:]
browser.ui.workingDataTree.dataItems.append(parentWidget)
def load_h5(browser, tree, push):
browser.ui.fileDataTree.data = []
index = browser.ui.dirTree.selectedIndexes()[0]
currentFile = str(index.model().filePath(index))
browser.currentFolder = os.path.dirname(currentFile)
if browser.db: browser.db.close()
if '.hdf5' in currentFile:
#print self.currentFile
browser.db = h5py.File(currentFile, 'r+')
tree.clear()
# Insert groups into the tree and add data to internal data list
for group in browser.db:
item = h5Item([str(group)])
item.path = '/'+str(group)
tree.addTopLevelItem(item)
populate_h5tree(browser, browser.db['/'+str(group)], parentWidget=item, push=push)
# Select first item of loaded list
tree.setCurrentItem(tree.itemAt(0,0))
if push:
browser.ui.workingDataTree.setSortingEnabled(True)
browser.ui.workingDataTree.propsDt = ''
browser.ui.workingDataTree.propsDescription = ''
for attr in browser.db.attrs:
#print attr, browser.db.attrs[attr]
if 'dt' in attr: browser.ui.workingDataTree.propsDt = str(browser.db.attrs[attr])
if 'description' in attr: browser.ui.workingDataTree.propsDescription = browser.db.attrs[attr]
table.update_table(browser)
browser.currentOpenFile = currentFile
browser.currentSaveFile = currentFile
browser.ui.workingDataTree.setHeaderLabels([os.path.split(currentFile)[1]])
browser.ui.workingDataTree.setSortingEnabled(False) # Otherwise it screws up drag and drop
def noProtocolNames(self):
# Get trigger times (in data points)
tarray = np.arange(0, len(self.triggers))
self.tevents = tarray[self.triggers > 0]
# Iterate names and add entries to data tree
protocolsItem = h5Item([str('protocols_data')])
self.parentItem.addChild(protocolsItem)
if self.eventsBox.isChecked():
itemPath = aux.selectItem_box(self.browser)
itemPath = itemPath.split('/')
root = self.browser.ui.workingDataTree.invisibleRootItem()
dataSourceItem = aux.getItemFromPath(itemPath, root, level=0)
if ('video'
in dataSourceItem.attrs) and (dataSourceItem.attrs['video']
== 'True'):
videoEvents = True
clip = VideoFileClip(dataSourceItem.attrs['mrl'])
item_triggers = h5Item([str('triggers')])
item_nontriggers = h5Item([str('non_triggers')])
item_manualtriggers = h5Item([str('manual')])
protocolsItem.addChild(item_triggers)
protocolsItem.addChild(item_nontriggers)
protocolsItem.addChild(item_manualtriggers)
for t in self.tevents:
triggerFrame = t
child = h5Item(['frame_' + str(triggerFrame)])
# Deal with data options
if self.eventsBox.isChecked():
if videoEvents:
tstart = (triggerFrame - self.baseline) / clip.fps
tend = (triggerFrame + self.duration) / clip.fps
subclip = clip.subclip(tstart, tend)
self.makeVideoStream(subclip, child)
else:
child.data = dataSourceItem.data[triggerFrame - self.
baseline:triggerFrame +
self.duration]
# todo: check whether there is data
if self.triggers[triggerFrame] == 1:
item_nontriggers.addChild(child)
elif self.triggers[triggerFrame] == 2:
item_triggers.addChild(child)
elif self.triggers[triggerFrame] == 3:
item_manualtriggers.addChild(child)
def clone_item(item):
""" Clone h5 item. Useful for Drag & Drop
"""
i = h5Item(item.text(0))
i.path = item.path
i.listIndex = item.dataIndex
i.originalIndex = item.originalIndex
i.data = item.data
return i
def clone_item(item):
""" Clone h5 item. Useful for Drag & Drop
"""
i = h5Item(item.text(0))
i.path = item.path
i.listIndex = item.dataIndex
i.originalIndex = item.originalIndex
i.data = item.data
return i
def noProtocolNames(self):
# Get trigger times (in data points)
tarray = np.arange(0, len(self.triggers))
self.tevents = tarray[self.triggers>0]
# Iterate names and add entries to data tree
protocolsItem = h5Item([str('protocols_data')])
self.parentItem.addChild(protocolsItem)
if self.eventsBox.isChecked():
itemPath = aux.selectItem_box(self.browser)
itemPath = itemPath.split('/')
root = self.browser.ui.workingDataTree.invisibleRootItem()
dataSourceItem = aux.getItemFromPath(itemPath, root, level=0)
if ('video' in dataSourceItem.attrs) and (dataSourceItem.attrs['video']=='True'):
videoEvents = True
clip = VideoFileClip(dataSourceItem.attrs['mrl'])
item_triggers = h5Item([str('triggers')])
item_nontriggers = h5Item([str('non_triggers')])
item_manualtriggers = h5Item([str('manual')])
protocolsItem.addChild(item_triggers)
protocolsItem.addChild(item_nontriggers)
protocolsItem.addChild(item_manualtriggers)
for t in self.tevents:
triggerFrame = t
child = h5Item(['frame_'+str(triggerFrame)])
# Deal with data options
if self.eventsBox.isChecked():
if videoEvents:
tstart = (triggerFrame-self.baseline)/clip.fps
tend = (triggerFrame+self.duration)/clip.fps
subclip = clip.subclip(tstart, tend)
self.makeVideoStream(subclip, child)
else:
child.data = dataSourceItem.data[triggerFrame-self.baseline:triggerFrame+self.duration]
# todo: check whether there is data
if self.triggers[triggerFrame]==1:
item_nontriggers.addChild(child)
elif self.triggers[triggerFrame]==2:
item_triggers.addChild(child)
elif self.triggers[triggerFrame]==3:
item_manualtriggers.addChild(child)
def make_data_copy(browser, plotWidget):
""" Make a copy of the currently plotted data to work on,
in order to keep the original data intact. Add new items
to the working data tree and plot them.
"""
parentText = plotWidget.plotDataItems[0].parent().text(0)
item = h5Item([parentText + '_OriginalCopy'])
parentWidget = browser.ui.workingDataTree.invisibleRootItem()
browser.make_nameUnique(parentWidget, item, item.text(0))
browser.ui.workingDataTree.addTopLevelItem(item)
childrenList = []
for plotItem in plotWidget.plotDataItems:
# Add items to tree
child = h5Item([str(plotItem.text(0))])
browser.make_nameUnique(item, child, child.text(0))
item.addChild(child)
child.attrs = plotItem.attrs
child.data = plotItem.data
child.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(child)
childrenList.append(child)
def save_results(browser, parentText, results):
""" Saves data to workingDataTree.data and adds
corresponding entry in the tree with a parent at
root level and children.
'results' is a list with n items ['label', data, attrs]
Returns a list with the list indexes of the stored items
"""
listIndexes = []
item = h5Item([parentText])
parentWidget = browser.ui.workingDataTree.invisibleRootItem()
browser.make_nameUnique(parentWidget, item, item.text(0))
browser.ui.workingDataTree.addTopLevelItem(item)
for result in results:
child = h5Item([result[0]])
browser.make_nameUnique(item, child, child.text(0))
item.addChild(child)
if len(result) > 2: child.attrs = result[2]
child.listIndex = len(browser.ui.workingDataTree.dataItems)
listIndexes.append(child.listIndex)
browser.ui.workingDataTree.dataItems.append(child)
child.data = result[1]
return listIndexes
def save_results(browser, parentText, results):
""" Saves data to workingDataTree.data and adds
corresponding entry in the tree with a parent at
root level and children.
'results' is a list with n items ['label', data, attrs]
Returns a list with the list indexes of the stored items
"""
listIndexes = []
item = h5Item([parentText])
parentWidget = browser.ui.workingDataTree.invisibleRootItem()
browser.make_nameUnique(parentWidget, item, item.text(0))
browser.ui.workingDataTree.addTopLevelItem(item)
for result in results:
child = h5Item([result[0]])
browser.make_nameUnique(item, child, child.text(0))
item.addChild(child)
if len(result)>2: child.attrs = result[2]
child.listIndex = len(browser.ui.workingDataTree.dataItems)
listIndexes.append(child.listIndex)
browser.ui.workingDataTree.dataItems.append(child)
child.data = result[1]
return listIndexes
def make_data_copy(browser, plotWidget):
""" Make a copy of the currently plotted data to work on,
in order to keep the original data intact. Add new items
to the working data tree and plot them.
"""
plotWidget.clear()
parentText = plotWidget.plotDataItems[0].parent().text(0)
item = h5Item([parentText+'_copy'])
parentWidget = browser.ui.workingDataTree.invisibleRootItem()
browser.make_nameUnique(parentWidget, item, item.text(0))
browser.ui.workingDataTree.addTopLevelItem(item)
childrenList = []
for plotItem in plotWidget.plotDataItems:
# Add items to tree
child = h5Item([str(plotItem.text(0))])
browser.make_nameUnique(item, child, child.text(0))
item.addChild(child)
child.attrs = plotItem.attrs
child.data = plotItem.data
child.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(child)
childrenList.append(child)
pgplot.plot_multipleData(browser, plotWidget, childrenList)
if browser.ui.actionShowCursors.isChecked(): pgplot.replot_cursors(browser, plotWidget)
def store_data(data, name='data', attrs={'dt':1}):
""" Adds data to the Data Tree
'data' is a number array of 1 or 2 dimensions
'name' is sring
'attrs' is a dictionary {attr1: value1, attr2, value2, ...}
"""
# Set root as parent
parentWidget = browser.ui.workingDataTree.invisibleRootItem()
# Make sure data is numpy array
data = np.array(data)
# 1D array - add straight to root with name 'name'
if len(data.shape)==1:
item = h5Item([name])
browser.make_nameUnique(parentWidget, item, item.text(0))
item.data = data
item.attrs = attrs
item.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(item)
browser.ui.workingDataTree.addTopLevelItem(item)
# 2D array - add 'name' group and 'data' datasets
elif len(data.shape)==2:
item = h5Item([name])
browser.make_nameUnique(parentWidget, item, item.text(0))
browser.ui.workingDataTree.addTopLevelItem(item)
for n in np.arange(0, len(data)):
child = h5Item(['data_'+str(n)])
browser.make_nameUnique(item, child, child.text(0))
child.data = data[n,:]
child.attrs = attrs
child.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(child)
item.addChild(child)
def populate_h5tree(browser, parent, parentWidget, push):
if isinstance(parent, h5py.Group):
for child in parent:
#print parent[child]
item = h5Item([child])
item.path = re.findall('"([^"]*)"', str(parent))[0] + '/' + str(child)
parentWidget.addChild(item)
populate_h5tree(browser, parent[child], item, push)
elif isinstance(parent, h5py.Dataset):
set_attrs(parent, parentWidget)
if push:
try:
parentWidget.data = parent[:]
parentWidget.listIndex = len(browser.ui.workingDataTree.dataItems)
#browser.ui.workingDataTree.data.append(parent[:])
browser.ui.workingDataTree.dataItems.append(parentWidget)
except ValueError: # No data in the dataset
sip.delete(parentWidget)
def populate_h5tree(browser, parent, parentWidget, push):
if isinstance(parent, h5py.Group):
for child in parent:
#print parent[child]
item = h5Item([child])
item.path = re.findall('"([^"]*)"',
str(parent))[0] + '/' + str(child)
parentWidget.addChild(item)
populate_h5tree(browser, parent[child], item, push)
elif isinstance(parent, h5py.Dataset):
set_attrs(parent, parentWidget)
if push:
try:
parentWidget.data = get_dataFromFile(browser, parentWidget)
parentWidget.listIndex = len(
browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(parentWidget)
except ValueError: # No data in the dataset
sip.delete(parentWidget)
def withProtocolNames(self):
# Get trigger times (in data points)
tarray = np.arange(0, len(self.triggers))
self.tevents = tarray[self.triggers > 0]
# Iterate names and add entries to data tree
protocols = list(set(self.names))
inames = list(enumerate(self.names))
protocolsItem = h5Item([str('protocols_data')])
self.parentItem.addChild(protocolsItem)
if self.eventsBox.isChecked():
itemPath = aux.selectItem_box(self.browser)
itemPath = itemPath.split('/')
for protocol in protocols:
item = h5Item([str(protocol)])
item_triggers = h5Item([str('triggers')])
item_nontriggers = h5Item([str('non_triggers')])
item_manualtriggers = h5Item([str('manual')])
item.addChild(item_triggers)
item.addChild(item_nontriggers)
item.addChild(item_manualtriggers)
for i in inames:
if i[1] == protocol:
triggerFrame = self.tevents[i[0]]
child = h5Item(['frame_' + str(triggerFrame)])
# Deal with data options
if self.eventsBox.isChecked():
root = self.browser.ui.workingDataTree.invisibleRootItem(
)
dataSourceItem = aux.getItemFromPath(itemPath,
root,
level=0)
#print [triggerFrame-self.baseline,triggerFrame+self.baseline]
if ('video' in dataSourceItem.attrs) and (
dataSourceItem.attrs['video'] == 'True'):
print 'this is a video'
else:
child.data = dataSourceItem.data[
triggerFrame - self.baseline:triggerFrame +
self.duration]
# todo: check whether there is data
if self.triggers[triggerFrame] == 1:
item_nontriggers.addChild(child)
elif self.triggers[triggerFrame] == 2:
item_triggers.addChild(child)
elif self.triggers[triggerFrame] == 3:
item_manualtriggers.addChild(child)
protocolsItem.addChild(item)
def func(self, browser):
""" Convert X-Y coordinates into speed
User selects Real-Time Coordinates item and speed is
added as a child
"""
############################################
# ANALYSIS FUNCTION
# Get widgets
self.plotWidget = browser.ui.dataPlotsWidget
self.toolsWidget = browser.ui.oneDimToolStackedWidget
# Get X and Y data from selected coordinates
x, y = [], []
parentItem = browser.ui.workingDataTree.selectedItems()[0]
for i in range(parentItem.childCount()):
item = parentItem.child(i)
if 'X' in item.text(0):
x = item.data
elif 'Y' in item.text(0):
y = item.data
if len(x) == 0 or len(y) == 0:
aux.error_box('XY coordinates not found')
return
# Calculate speed
d = []
dt = item.attrs['dt']
for i in range(1, len(x)):
xmov = x[i] - x[i - 1]
ymov = y[i] - y[i - 1]
d.append(np.sqrt((xmov**2) + (ymov**2)))
speed = d # px/frame > px/s = speed/(1./dt) with dt in seconds
# Store data
speedItem = h5Item(['speed'])
speedItem.data = np.array(speed)
parentItem.addChild(speedItem)
def func(self, browser):
""" Convert X-Y coordinates into speed
User selects Real-Time Coordinates item and speed is
added as a child
"""
############################################
# ANALYSIS FUNCTION
# Get widgets
self.plotWidget = browser.ui.dataPlotsWidget
self.toolsWidget = browser.ui.oneDimToolStackedWidget
# Get X and Y data from selected coordinates
x, y = [], []
parentItem = browser.ui.workingDataTree.selectedItems()[0]
for i in range(parentItem.childCount()):
item = parentItem.child(i)
if 'X' in item.text(0):
x = item.data
elif 'Y' in item.text(0):
y = item.data
if len(x)==0 or len(y)==0:
aux.error_box('XY coordinates not found')
return
# Calculate speed
d = []
dt = item.attrs['dt']
for i in range(1, len(x)):
xmov = x[i] - x[i-1]
ymov = y[i] - y[i-1]
d.append(np.sqrt((xmov**2) + (ymov**2)))
speed = d # px/frame > px/s = speed/(1./dt) with dt in seconds
# Store data
speedItem = h5Item(['speed'])
speedItem.data = np.array(speed)
parentItem.addChild(speedItem)
def withProtocolNames(self):
# Get trigger times (in data points)
tarray = np.arange(0, len(self.triggers))
self.tevents = tarray[self.triggers>0]
# Iterate names and add entries to data tree
protocols = list(set(self.names))
inames = list(enumerate(self.names))
protocolsItem = h5Item([str('protocols_data')])
self.parentItem.addChild(protocolsItem)
if self.eventsBox.isChecked():
itemPath = aux.selectItem_box(self.browser)
itemPath = itemPath.split('/')
for protocol in protocols:
item = h5Item([str(protocol)])
item_triggers = h5Item([str('triggers')])
item_nontriggers = h5Item([str('non_triggers')])
item_manualtriggers = h5Item([str('manual')])
item.addChild(item_triggers)
item.addChild(item_nontriggers)
item.addChild(item_manualtriggers)
for i in inames:
if i[1] == protocol:
triggerFrame = self.tevents[i[0]]
child = h5Item(['frame_'+str(triggerFrame)])
# Deal with data options
if self.eventsBox.isChecked():
root = self.browser.ui.workingDataTree.invisibleRootItem()
dataSourceItem = aux.getItemFromPath(itemPath, root, level=0)
#print [triggerFrame-self.baseline,triggerFrame+self.baseline]
if ('video' in dataSourceItem.attrs) and (dataSourceItem.attrs['video']=='True'):
print 'this is a video'
else:
child.data = dataSourceItem.data[triggerFrame-self.baseline:triggerFrame+self.duration]
# todo: check whether there is data
if self.triggers[triggerFrame]==1:
item_nontriggers.addChild(child)
elif self.triggers[triggerFrame]==2:
item_triggers.addChild(child)
elif self.triggers[triggerFrame]==3:
item_manualtriggers.addChild(child)
protocolsItem.addChild(item)
def store_data(data, array2D=False, name='data', attrs={'dt': 1}):
""" Adds data to the Data Tree
'data' is a number array of 1 or 2 dimensions
'name' is sring
'attrs' is a dictionary {attr1: value1, attr2, value2, ...}
If array2D==True the data are stored as a 2D-array
"""
# Set root as parent
parentWidget = browser.ui.workingDataTree.invisibleRootItem()
# Make sure data is numpy array
#data = np.array(data)
# List - add 'name' group and 'data' datasets
if isinstance(data, list):
item = h5Item([name])
browser.make_nameUnique(parentWidget, item, item.text(0))
browser.ui.workingDataTree.addTopLevelItem(item)
for n in np.arange(0, len(data)):
child = h5Item(['data_' + str(n)])
browser.make_nameUnique(item, child, child.text(0))
child.data = data[n]
child.attrs = attrs
child.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(child)
item.addChild(child)
# Float - add straight to root with name 'name'
#elif isinstance(data, float):
# item = h5Item([name])
# browser.make_nameUnique(parentWidget, item, item.text(0))
# item.data = data
# item.attrs = attrs
# item.listIndex = len(browser.ui.workingDataTree.dataItems)
# browser.ui.workingDataTree.dataItems.append(item)
# browser.ui.workingDataTree.addTopLevelItem(item)
# 1D array - add straight to root with name 'name'
elif (len(data.shape) == 1) or ((len(data.shape) == 2) and
(array2D == True)):
item = h5Item([name])
browser.make_nameUnique(parentWidget, item, item.text(0))
item.data = data
item.attrs = attrs
item.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(item)
browser.ui.workingDataTree.addTopLevelItem(item)
# 2D array - add 'name' group and 'data' datasets
elif (len(data.shape) == 2) and (array2D == False):
item = h5Item([name])
browser.make_nameUnique(parentWidget, item, item.text(0))
browser.ui.workingDataTree.addTopLevelItem(item)
for n in np.arange(0, len(data)):
child = h5Item(['data_' + str(n)])
browser.make_nameUnique(item, child, child.text(0))
child.data = data[n, :]
child.attrs = attrs
child.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(child)
item.addChild(child)
def store_data(data, array2D=False, name='data', attrs={'dt':1}):
""" Adds data to the Data Tree
'data' is a number array of 1 or 2 dimensions
'name' is sring
'attrs' is a dictionary {attr1: value1, attr2, value2, ...}
If array2D==True the data are stored as a 2D-array
"""
# Set root as parent
parentWidget = browser.ui.workingDataTree.invisibleRootItem()
# Make sure data is numpy array
#data = np.array(data)
# List - add 'name' group and 'data' datasets
if isinstance(data, list):
item = h5Item([name])
browser.make_nameUnique(parentWidget, item, item.text(0))
browser.ui.workingDataTree.addTopLevelItem(item)
for n in np.arange(0, len(data)):
child = h5Item(['data_'+str(n)])
browser.make_nameUnique(item, child, child.text(0))
child.data = data[n]
child.attrs = attrs
child.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(child)
item.addChild(child)
# Float - add straight to root with name 'name'
#elif isinstance(data, float):
# item = h5Item([name])
# browser.make_nameUnique(parentWidget, item, item.text(0))
# item.data = data
# item.attrs = attrs
# item.listIndex = len(browser.ui.workingDataTree.dataItems)
# browser.ui.workingDataTree.dataItems.append(item)
# browser.ui.workingDataTree.addTopLevelItem(item)
# 1D array - add straight to root with name 'name'
elif (len(data.shape)==1) or ((len(data.shape)==2) and (array2D==True)):
item = h5Item([name])
browser.make_nameUnique(parentWidget, item, item.text(0))
item.data = data
item.attrs = attrs
item.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(item)
browser.ui.workingDataTree.addTopLevelItem(item)
# 2D array - add 'name' group and 'data' datasets
elif (len(data.shape)==2) and (array2D==False):
item = h5Item([name])
browser.make_nameUnique(parentWidget, item, item.text(0))
browser.ui.workingDataTree.addTopLevelItem(item)
for n in np.arange(0, len(data)):
child = h5Item(['data_'+str(n)])
browser.make_nameUnique(item, child, child.text(0))
child.data = data[n,:]
child.attrs = attrs
child.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(child)
item.addChild(child)
def load_h5(browser, tree, push):
""" Main loading function. Initially written for .hdf5 files only,
but now also load .tdms files.
The whole thing could use with consolidating the code, there
is redundancy and some of the functionality is not necessary.
"""
browser.ui.fileDataTree.data = []
index = browser.ui.dirTree.selectedIndexes()[0]
currentFile = str(index.model().filePath(index))
browser.currentFolder = os.path.dirname(currentFile)
browser.ui.loadFolderInput.setText(browser.currentFolder)
if '.hdf5' in currentFile:
if browser.db: browser.db.close()
browser.db = h5py.File(currentFile, 'r+')
browser.dbType = 'hdf5'
tree.clear()
# Insert groups into the tree and add data to internal data list
for group in browser.db:
item = h5Item([str(group)])
item.path = '/' + str(group)
set_attrs(browser.db[group], item)
tree.addTopLevelItem(item)
populate_h5tree(browser,
browser.db['/' + str(group)],
parentWidget=item,
push=push)
# Select first item of loaded list
tree.setCurrentItem(tree.itemAt(0, 0))
if push:
browser.saveFolder = browser.currentFolder
browser.ui.saveFolderInput.setText(browser.saveFolder)
browser.ui.workingDataTree.setSortingEnabled(True)
browser.ui.notesWidget.clear()
for attr in browser.db.attrs:
browser.ui.workingDataTree.root.attrs[attr] = browser.db.attrs[
attr]
if 'Notes' in attr:
browser.ui.notesWidget.setText(browser.db.attrs['Notes'])
#if 'dt' in attr: browser.ui.workingDataTree.propsDt = str(browser.db.attrs[attr])
if 'description' in attr:
browser.ui.propsTableWidget.setData(
{'Description': [browser.db.attrs['description']]})
#table.update_props(browser)
browser.currentOpenFile = currentFile
browser.currentSaveFile = currentFile
browser.ui.workingDataTree.setHeaderLabels(
[os.path.split(currentFile)[1]])
browser.ui.workingDataTree.setSortingEnabled(
False) # Otherwise it screws up drag and drop
if '.abf' in currentFile:
browser.db = io.AxonIO(filename=currentFile)
browser.dbType = 'abf'
tree.clear()
# read data
browser.bl = browser.db.read_block(lazy=False, cascade=True)
nSweeps = len(browser.bl.segments)
signal = browser.bl.segments[0].analogsignals
signalItem = signal.pop()
samplingRate = np.array(signalItem.sampling_rate) # Hz
if 'A' in str(signalItem.units):
groupname = 'current'
else:
groupname = 'voltage'
item = h5Item([groupname])
tree.addTopLevelItem(item)
browser.bl = browser.db.read_block(lazy=False, cascade=True)
browser.saveFolder = browser.currentFolder
browser.ui.saveFolderInput.setText(browser.saveFolder)
browser.ui.workingDataTree.setSortingEnabled(True)
browser.ui.notesWidget.clear()
browser.currentOpenFile = currentFile
browser.currentSaveFile = os.path.splitext(currentFile)[0] + '.hdf5'
browser.ui.workingDataTree.setHeaderLabels(
[os.path.split(browser.currentSaveFile)[1]])
browser.ui.workingDataTree.setSortingEnabled(
False) # Otherwise it screws up drag and drop
for sweep in np.arange(1, nSweeps):
datasetname = 'sweep_' + str(sweep)
child = h5Item([datasetname])
child.sweep = sweep
child.attrs['dt'] = 1. / (samplingRate / 1000.)
item.addChild(child)
if push:
child.data = get_dataFromFile(browser, child)
# Deal with strings (display in Notes and convert to ASCII)
text = []
if (isinstance(child.data[0], basestring)) == True:
browser.ui.notesWidget.append(str(channelname))
for d in child.data:
if bool(d): text.append(d) # Get rid of empty strings
child.data = np.string_(
text) # Convert to fixed length ASCII
for t in text:
browser.ui.notesWidget.append(t)
browser.ui.notesWidget.append('\r')
child.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(child)
elif '.tdms' in currentFile:
browser.db = TdmsFile(currentFile)
browser.dbType = 'tdms'
tree.clear()
# Deal with properties
for attr in browser.db.object().properties:
if 'kHz' in attr:
browser.ui.fileDataTree.root.attrs[
'sampling_rate(kHz)'] = browser.db.object(
).properties[attr]
if push:
browser.ui.workingDataTree.root.attrs[
'sampling_rate(kHz)'] = browser.db.object(
).properties[attr]
browser.ui.fileDataTree.root.attrs[attr] = browser.db.object(
).properties[attr]
if push:
browser.ui.workingDataTree.root.attrs[
attr] = browser.db.object().properties[attr]
# Insert groups into the tree and add data to internal data list
if push:
try:
browser.db.object().properties['imaging']
imaging = True
except KeyError:
imaging = False
browser.saveFolder = browser.currentFolder
browser.ui.saveFolderInput.setText(browser.saveFolder)
browser.ui.workingDataTree.setSortingEnabled(True)
browser.ui.notesWidget.clear()
browser.currentOpenFile = currentFile
browser.currentSaveFile = os.path.splitext(
currentFile)[0] + '.hdf5'
browser.ui.workingDataTree.setHeaderLabels(
[os.path.split(browser.currentSaveFile)[1]])
browser.ui.workingDataTree.setSortingEnabled(
False) # Otherwise it screws up drag and drop
for group in browser.db.groups():
item = h5Item([str(group)])
tree.addTopLevelItem(item)
for channel in browser.db.group_channels(group):
channelname = re.findall(r"'(.*?)'", channel.path,
re.DOTALL)[1]
child = h5Item([str(channelname)])
child.group = group
child.channel = channelname
item.addChild(child)
if 'kHz' in str(tree.root.attrs):
child.attrs[
'dt'] = 1. / tree.root.attrs['sampling_rate(kHz)']
if push:
child.data = get_dataFromFile(browser, child)
if imaging:
pixels = float(
browser.db.object().properties['pixels_per_line'])
lines = float(
browser.db.object().properties['lines_per_frame'])
imageArray = imagefun.array2image(
child.data, (pixels, lines))
child.data = imageArray
# Deal with strings (display in Notes and convert to ASCII)
text = []
if (isinstance(child.data[0], basestring)) == True:
browser.ui.notesWidget.append(str(channelname))
for d in child.data:
if bool(d):
text.append(d) # Get rid of empty strings
child.data = np.string_(
text) # Convert to fixed length ASCII
for t in text:
browser.ui.notesWidget.append(t)
browser.ui.notesWidget.append('\r')
child.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(child)
#if 'kHz' in str(browser.ui.workingDataTree.root.attrs):
# child.attrs['dt'] = 1./browser.ui.workingDataTree.root.attrs['sampling_rate(kHz)']
elif '.mp4' in currentFile:
browser.dbType = 'video'
tree.clear()
item = h5Item(['Video stream'])
item.attrs['mrl'] = currentFile
item.attrs['video'] = 'True'
tree.addTopLevelItem(item)
# Read and show some properties
clip = VideoFileClip(currentFile)
resolution = h5Item(
['Resolution: ' + str(clip.size[0]) + 'x' + str(clip.size[1])])
item.addChild(resolution)
frameRate = h5Item(['Frame rate: ' + str(clip.fps)])
item.addChild(frameRate)
duration = h5Item(['Duration: ' + str(clip.duration) + ' sec'])
item.addChild(duration)
def move_itemsAcross(self, source, modifiers):
""" Create new tree items and populate the target tree. Originally made
for moving items from fileDataTree to workingDataTree, but then modified
to copy items when the move is internal in workingDataTree and Ctrl is
pressed.
"""
if (source
== self.ui.workingDataTree) and (modifiers
== QtCore.Qt.ControlModifier):
# Copy internally
#print 'copying'
targetItems = []
for item in self.copyItems:
i = h5Item([str(item.text(0))])
i.data = item.data
targetItems.append(i)
parentIndex = self.ui.workingDataTree.indexFromItem(
self.dragTargetParent)
for row in np.arange(0, len(self.copyItems)):
index = self.ui.workingDataTree.model().index(
self.dragTargetRow + row, 0, parentIndex)
temp_item = self.ui.workingDataTree.itemFromIndex(
QtCore.QModelIndex(index))
sip.delete(temp_item)
if parentIndex.isValid():
self.make_nameUnique(self.dragTargetParent,
targetItems[row],
targetItems[row].text(0))
self.dragTargetParent.insertChild(index.row(),
targetItems[row])
originalParentWidget = self.copyItems[row]
h5.populate_h5copyItems(self, originalParentWidget,
targetItems[row])
else:
self.make_nameUnique(
self.ui.workingDataTree.invisibleRootItem(),
targetItems[row], targetItems[row].text(0))
self.ui.workingDataTree.insertTopLevelItem(
index.row(), targetItems[row])
originalParentWidget = self.copyItems[row]
h5.populate_h5copyItems(self, originalParentWidget,
targetItems[row])
elif source == self.ui.workingDataTree:
pass
else:
# Move across
#print 'moving'
targetItems = []
for item in self.dragItems:
i = h5Item([str(item[1])])
i.path = item[0]
i.listIndex = item[2]
i.originalIndex = item[3]
i.data = item[4]
i.attrs = item[5]
#item = i[0]
#item.originalIndex = i[1]
targetItems.append(i)
parentIndex = self.ui.workingDataTree.indexFromItem(
self.dragTargetParent)
for row in np.arange(0, len(self.dragItems)):
index = self.ui.workingDataTree.model().index(
self.dragTargetRow + row, 0, parentIndex)
temp_item = self.ui.workingDataTree.itemFromIndex(
QtCore.QModelIndex(index))
sip.delete(temp_item)
if parentIndex.isValid():
self.make_nameUnique(self.dragTargetParent,
targetItems[row],
targetItems[row].text(0))
self.dragTargetParent.insertChild(index.row(),
targetItems[row])
originalParentWidget = self.ui.fileDataTree.itemFromIndex(
QtCore.QModelIndex(targetItems[row].originalIndex))
h5.populate_h5dragItems(self, originalParentWidget,
targetItems[row])
else:
self.make_nameUnique(
self.ui.workingDataTree.invisibleRootItem(),
targetItems[row], targetItems[row].text(0))
self.ui.workingDataTree.insertTopLevelItem(
index.row(), targetItems[row])
originalParentWidget = self.ui.fileDataTree.itemFromIndex(
QtCore.QModelIndex(targetItems[row].originalIndex))
h5.populate_h5dragItems(self, originalParentWidget,
targetItems[row])
def load_h5(browser, tree, push):
""" Main loading function. Initially written for .hdf5 files only,
but now also load .tdms files.
The whole thing could use with consolidating the code, there
is redundancy and some of the functionality is not necessary.
"""
browser.ui.fileDataTree.data = []
index = browser.ui.dirTree.selectedIndexes()[0]
currentFile = str(index.model().filePath(index))
browser.currentFolder = os.path.dirname(currentFile)
browser.ui.loadFolderInput.setText(browser.currentFolder)
if '.hdf5' in currentFile:
if browser.db: browser.db.close()
browser.db = h5py.File(currentFile, 'r+')
browser.dbType = 'hdf5'
tree.clear()
# Insert groups into the tree and add data to internal data list
for group in browser.db:
item = h5Item([str(group)])
item.path = '/'+str(group)
set_attrs(browser.db[group], item)
tree.addTopLevelItem(item)
populate_h5tree(browser, browser.db['/'+str(group)], parentWidget=item, push=push)
# Select first item of loaded list
tree.setCurrentItem(tree.itemAt(0,0))
if push:
browser.saveFolder = browser.currentFolder
browser.ui.saveFolderInput.setText(browser.saveFolder)
browser.ui.workingDataTree.setSortingEnabled(True)
browser.ui.notesWidget.clear()
for attr in browser.db.attrs:
browser.ui.workingDataTree.root.attrs[attr] = browser.db.attrs[attr]
if 'Notes' in attr: browser.ui.notesWidget.setText(browser.db.attrs['Notes'])
#if 'dt' in attr: browser.ui.workingDataTree.propsDt = str(browser.db.attrs[attr])
if 'description' in attr: browser.ui.propsTableWidget.setData({'Description':[browser.db.attrs['description']]})
#table.update_props(browser)
browser.currentOpenFile = currentFile
browser.currentSaveFile = currentFile
browser.ui.workingDataTree.setHeaderLabels([os.path.split(currentFile)[1]])
browser.ui.workingDataTree.setSortingEnabled(False) # Otherwise it screws up drag and drop
if '.abf' in currentFile:
browser.db = io.AxonIO(filename=currentFile)
browser.dbType = 'abf'
tree.clear()
# read data
browser.bl = browser.db.read_block(lazy=False, cascade=True)
nSweeps = len(browser.bl.segments)
signal = browser.bl.segments[0].analogsignals
signalItem = signal.pop()
samplingRate = np.array(signalItem.sampling_rate) # Hz
if 'A' in str(signalItem.units):
groupname = 'current'
else:
groupname = 'voltage'
item = h5Item([groupname])
tree.addTopLevelItem(item)
browser.bl = browser.db.read_block(lazy=False, cascade=True)
browser.saveFolder = browser.currentFolder
browser.ui.saveFolderInput.setText(browser.saveFolder)
browser.ui.workingDataTree.setSortingEnabled(True)
browser.ui.notesWidget.clear()
browser.currentOpenFile = currentFile
browser.currentSaveFile = os.path.splitext(currentFile)[0]+'.hdf5'
browser.ui.workingDataTree.setHeaderLabels([os.path.split(browser.currentSaveFile)[1]])
browser.ui.workingDataTree.setSortingEnabled(False) # Otherwise it screws up drag and drop
for sweep in np.arange(1,nSweeps):
datasetname = 'sweep_'+str(sweep)
child = h5Item([datasetname])
child.sweep = sweep
child.attrs['dt'] = 1./(samplingRate/1000.)
item.addChild(child)
if push:
child.data = get_dataFromFile(browser, child)
# Deal with strings (display in Notes and convert to ASCII)
text = []
if (isinstance(child.data[0], basestring))==True:
browser.ui.notesWidget.append(str(channelname))
for d in child.data:
if bool(d): text.append(d) # Get rid of empty strings
child.data = np.string_(text) # Convert to fixed length ASCII
for t in text:
browser.ui.notesWidget.append(t)
browser.ui.notesWidget.append('\r')
child.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(child)
elif '.tdms' in currentFile:
browser.db = TdmsFile(currentFile)
browser.dbType = 'tdms'
tree.clear()
# Deal with properties
for attr in browser.db.object().properties:
if 'kHz' in attr:
browser.ui.fileDataTree.root.attrs['sampling_rate(kHz)'] = browser.db.object().properties[attr]
if push:
browser.ui.workingDataTree.root.attrs['sampling_rate(kHz)'] = browser.db.object().properties[attr]
browser.ui.fileDataTree.root.attrs[attr] = browser.db.object().properties[attr]
if push:
browser.ui.workingDataTree.root.attrs[attr] = browser.db.object().properties[attr]
# Insert groups into the tree and add data to internal data list
if push:
try:
browser.db.object().properties['imaging']
imaging = True
except KeyError:
imaging = False
browser.saveFolder = browser.currentFolder
browser.ui.saveFolderInput.setText(browser.saveFolder)
browser.ui.workingDataTree.setSortingEnabled(True)
browser.ui.notesWidget.clear()
browser.currentOpenFile = currentFile
browser.currentSaveFile = os.path.splitext(currentFile)[0]+'.hdf5'
browser.ui.workingDataTree.setHeaderLabels([os.path.split(browser.currentSaveFile)[1]])
browser.ui.workingDataTree.setSortingEnabled(False) # Otherwise it screws up drag and drop
for group in browser.db.groups():
item = h5Item([str(group)])
tree.addTopLevelItem(item)
for channel in browser.db.group_channels(group):
channelname = re.findall(r"'(.*?)'", channel.path , re.DOTALL)[1]
child = h5Item([str(channelname)])
child.group = group
child.channel = channelname
item.addChild(child)
if 'kHz' in str(tree.root.attrs):
child.attrs['dt'] = 1./tree.root.attrs['sampling_rate(kHz)']
if push:
child.data = get_dataFromFile(browser, child)
if imaging:
pixels = float(browser.db.object().properties['pixels_per_line'])
lines = float(browser.db.object().properties['lines_per_frame'])
imageArray = imagefun.array2image(child.data, (pixels,lines))
child.data = imageArray
# Deal with strings (display in Notes and convert to ASCII)
text = []
if (isinstance(child.data[0], basestring))==True:
browser.ui.notesWidget.append(str(channelname))
for d in child.data:
if bool(d): text.append(d) # Get rid of empty strings
child.data = np.string_(text) # Convert to fixed length ASCII
for t in text:
browser.ui.notesWidget.append(t)
browser.ui.notesWidget.append('\r')
child.listIndex = len(browser.ui.workingDataTree.dataItems)
browser.ui.workingDataTree.dataItems.append(child)
#if 'kHz' in str(browser.ui.workingDataTree.root.attrs):
# child.attrs['dt'] = 1./browser.ui.workingDataTree.root.attrs['sampling_rate(kHz)']
elif '.mp4' in currentFile:
browser.dbType = 'video'
tree.clear()
item = h5Item(['Video stream'])
item.attrs['mrl'] = currentFile
item.attrs['video'] = 'True'
tree.addTopLevelItem(item)
# Read and show some properties
clip = VideoFileClip(currentFile)
resolution = h5Item(['Resolution: '+str(clip.size[0])+'x'+str(clip.size[1])])
item.addChild(resolution)
frameRate = h5Item(['Frame rate: '+str(clip.fps)])
item.addChild(frameRate)
duration = h5Item(['Duration: '+str(clip.duration)+' sec'])
item.addChild(duration)
