def mouseDoubleClickEvent(self, event):
"""
On double click, find closest pen sample to mouse pos and select
the sample's segment (if it has been assigned to one).
"""
if MarkWriteMainWindow.instance().project:
pdat = self.getCurrentPenData()
if len(pdat):
streg = MarkWriteMainWindow.instance().project.selectedtimeregion
if streg:
xmin, xmax = streg.getRegion()
data_pos = self.dataplots['xy_plot'].vb.mapSceneToView(event.pos())
x = data_pos.x()
if x < xmin or x > xmax:
ptime_ix = len(pdat['time'][pdat['time']<=x])
if ptime_ix > 0:
seg_id = pdat[ptime_ix]['segment_id']
if seg_id > 0:
seg = PenDataSegment.id2obj[seg_id]
if seg.l1seg==seg:
# Do not select segment if it is an L1
pass
else:
MarkWriteMainWindow.instance().setActiveObject(seg)
streg._ignore_events=True
super(PenDataTemporalPlotWidget,self).mouseDoubleClickEvent(event)
streg._ignore_events=False
else:
super(PenDataTemporalPlotWidget,self).mouseDoubleClickEvent(event)
def updateSelectedPenPointsGraphics(self, selectedpendata=None):
if selectedpendata is None:
selectedpendata = MarkWriteMainWindow.instance().project.selectedpendata
pen=pen2=None
brush=brush2=None
psize=SETTINGS['spatialplot_selectedpoint_size']
if MarkWriteMainWindow.instance().project.isSelectedDataValidForNewSegment():
pen = pg.mkPen(SETTINGS['spatialplot_selectedvalid_color'],
width=SETTINGS['spatialplot_selectedpoint_size'])
pen2 = pg.mkPen(SETTINGS['spatialplot_selectedvalid_color'].darker(300),
width=SETTINGS['spatialplot_selectedpoint_size'])
brush = pg.mkBrush(SETTINGS['spatialplot_selectedvalid_color'])
brush2 = pg.mkBrush(SETTINGS['spatialplot_selectedvalid_color'].darker(300))
else:
pen = pg.mkPen(SETTINGS['spatialplot_selectedinvalid_color'],
width=SETTINGS['spatialplot_selectedpoint_size'])
brush = pg.mkBrush(SETTINGS['spatialplot_selectedinvalid_color'])
pen2 = pg.mkPen(SETTINGS['spatialplot_selectedinvalid_color'].darker(300),
width=SETTINGS['spatialplot_selectedpoint_size'])
brush2 = pg.mkBrush(SETTINGS['spatialplot_selectedinvalid_color'].darker(300))
penarray = np.empty(selectedpendata.shape[0], dtype=object)
penarray[:] = pen
penarray[selectedpendata['pressure'] == 0] = pen2
brusharray = np.empty(selectedpendata.shape[0], dtype=object)
brusharray[:] = brush
brusharray[selectedpendata['pressure'] == 0] = brush2
self.selectedPlotDataItem.setData(x=selectedpendata[X_FIELD],
y=selectedpendata[Y_FIELD], pen=None,
symbol='o', symbolSize=psize,
symbolBrush=brusharray, symbolPen=penarray)
def __init__(self):
pg.GraphicsLayoutWidget.__init__(self)
# Create Pen Position Time Series Plot for All Data
self.dataplots=dict()
self.plotitems=dict()
ylabel = dict(axis='left', text="Position")
mouseenabled = {'y':SETTINGS['timeplot_enable_ymouse']}
last_plot = self.addSubPlot("xy_plot", 0, setMenuEnabled=False,
setMouseEnabled=mouseenabled, hideAxis='bottom',
setLabel=ylabel)
self.nextRow()
last_plot = self.createVelocityPlot(mouseenabled)
self.nextRow()
self.createAccelerationPlot(mouseenabled)
self.bottom_plot.setLabel('bottom', text="Time", units='sec')
self.currentSelection = None
self.fullPenValRange=[0,1]
self.maxTime=1
self._lastselectedtimerange = None
self._level1Segment = None
self._enablePopupDisplay = True
MarkWriteMainWindow.instance().sigResetProjectData.connect(
self.handleResetPenData)
MarkWriteMainWindow.instance().sigActiveObjectChanged.connect(
self.handleSelectedObjectChanged)
def handleUpdatedSettingsEvent(self, updates, settings):
selectedpendata = MarkWriteMainWindow.instance().project.selectedpendata
#pdat = MarkWriteMainWindow.instance().project.pendata
pdat = self.getCurrentPenData()
for k in updates.keys():
if k.startswith('spatialplot_default'):
brusharray, penarray = self.createDefaultPenBrushForData(pdat)
self.allPlotDataItem.setData(x=pdat[X_FIELD], y=pdat[Y_FIELD],
symbolBrush=brusharray,
symbolPen=penarray)
break
for k in updates.keys():
if k.startswith('spatialplot_selected'):
self.updateSelectedPenPointsGraphics(selectedpendata)
break
for k in updates.keys():
if k.startswith('pen_stroke_boundary'):
proj = MarkWriteMainWindow.instance().project
pstart, pend = pdat['time'][[0,-1]]
vms_times = proj.stroke_boundary_samples['time']
vms_mask = (vms_times >= pstart) & (vms_times <= pend)
self.addStrokeBoundaryPoints(proj.stroke_boundary_samples[vms_mask])
if 'spatialplot_invert_y_axis' in updates.keys():
self.getPlotItem().invertY(SETTINGS['spatialplot_invert_y_axis'])
def mouseDoubleClickEvent(self, event):
"""
On double click, find closest pen sample to mouse pos and select
the sample's segment (if it has been assigned to one).
"""
if MarkWriteMainWindow.instance().project:
pdat = self.getCurrentPenData()
if len(pdat):
streg = MarkWriteMainWindow.instance(
).project.selectedtimeregion
if streg:
xmin, xmax = streg.getRegion()
data_pos = self.dataplots['xy_plot'].vb.mapSceneToView(
event.pos())
x = data_pos.x()
if x < xmin or x > xmax:
ptime_ix = len(pdat['time'][pdat['time'] <= x])
if ptime_ix > 0:
seg_id = pdat[ptime_ix]['segment_id']
if seg_id > 0:
seg = PenDataSegment.id2obj[seg_id]
if seg.l1seg == seg:
# Do not select segment if it is an L1
pass
else:
MarkWriteMainWindow.instance(
).setActiveObject(seg)
streg._ignore_events = True
super(PenDataTemporalPlotWidget,
self).mouseDoubleClickEvent(event)
streg._ignore_events = False
else:
super(PenDataTemporalPlotWidget,
self).mouseDoubleClickEvent(event)
def __init__(self):
pg.GraphicsLayoutWidget.__init__(self)
# Create Pen Position Time Series Plot for All Data
self.dataplots = dict()
self.plotitems = dict()
ylabel = dict(axis='left', text="Position")
mouseenabled = {'y': SETTINGS['timeplot_enable_ymouse']}
last_plot = self.addSubPlot("xy_plot",
0,
setMenuEnabled=False,
setMouseEnabled=mouseenabled,
hideAxis='bottom',
setLabel=ylabel)
self.nextRow()
last_plot = self.createVelocityPlot(mouseenabled)
self.nextRow()
self.createAccelerationPlot(mouseenabled)
self.bottom_plot.setLabel('bottom', text="Time", units='sec')
self.currentSelection = None
self.fullPenValRange = [0, 1]
self.maxTime = 1
self._lastselectedtimerange = None
self._level1Segment = None
self._enablePopupDisplay = True
MarkWriteMainWindow.instance().sigResetProjectData.connect(
self.handleResetPenData)
MarkWriteMainWindow.instance().sigActiveObjectChanged.connect(
self.handleSelectedObjectChanged)
def handleUpdatedSettingsEvent(self, updates, settings):
selectedpendata = MarkWriteMainWindow.instance(
).project.selectedpendata
#pdat = MarkWriteMainWindow.instance().project.pendata
pdat = self.getCurrentPenData()
for k in updates.keys():
if k.startswith('spatialplot_default'):
brusharray, penarray = self.createDefaultPenBrushForData(pdat)
self.allPlotDataItem.setData(x=pdat[X_FIELD],
y=pdat[Y_FIELD],
symbolBrush=brusharray,
symbolPen=penarray)
break
for k in updates.keys():
if k.startswith('spatialplot_selected'):
self.updateSelectedPenPointsGraphics(selectedpendata)
break
for k in updates.keys():
if k.startswith('pen_stroke_boundary'):
proj = MarkWriteMainWindow.instance().project
pstart, pend = pdat['time'][[0, -1]]
vms_times = proj.stroke_boundary_samples['time']
vms_mask = (vms_times >= pstart) & (vms_times <= pend)
self.addStrokeBoundaryPoints(
proj.stroke_boundary_samples[vms_mask], vms_mask)
if 'spatialplot_invert_y_axis' in updates.keys():
self.getPlotItem().invertY(SETTINGS['spatialplot_invert_y_axis'])
def handleSegmentRemoved(self, segment, segment_index):
self.doNotSetActiveObject = True
parent_tree_node = self.segid2treenode[segment.parent.id]
segmenttreeitem = parent_tree_node.child(segment_index)
parent_tree_node.removeChild(segmenttreeitem)
self.doNotSetActiveObject = False
if MarkWriteMainWindow.instance():
MarkWriteMainWindow.instance().setActiveObject(segment.parent)
def handleSegmentRemoved(self, segment, segment_index):
self.doNotSetActiveObject = True
parent_tree_node = self.segid2treenode[segment.parent.id]
segmenttreeitem = parent_tree_node.child(segment_index)
parent_tree_node.removeChild(segmenttreeitem)
self.doNotSetActiveObject = False
if MarkWriteMainWindow.instance():
MarkWriteMainWindow.instance().setActiveObject(segment.parent)
def handlePenDataSelectionChanged(self):
self.currentSelection.setZValue(10)
minT, maxT , selectedpendata= self.currentSelection.selectedtimerangeanddata
# print '>> Timeline.handlePenDataSelectionChanged:',( minT, maxT)
MarkWriteMainWindow.instance().sigSelectedPenDataUpdate.emit((minT, maxT),
selectedpendata)
self.ensureSelectionIsVisible([minT, maxT], selectedpendata)
def rightClickTreeEvent(self, *args, **kwargs):
# Show Segment name editing dialog
segment = MarkWriteMainWindow.instance().activeobject
#print "rightClickTreeEvent:",segment
if segment:
if isinstance(segment, PenDataSegmentCategory):
if segment.locked is False:
tag, ok = showSegmentNameDialog(
MarkWriteMainWindow.instance().predefinedtags, default=segment.name)
if len(tag) > 0 and ok:
segment.name = tag
self.project_tree.selectedItems()[0].setText(0,
segment.name)
def rightClickTreeEvent(self, *args, **kwargs):
# Show Segment name editing dialog
segment = MarkWriteMainWindow.instance().activeobject
#print "rightClickTreeEvent:",segment
if segment:
if isinstance(segment, PenDataSegmentCategory):
if segment.locked is False:
tag, ok = showSegmentNameDialog(
MarkWriteMainWindow.instance().predefinedtags,
default=segment.name)
if len(tag) > 0 and ok:
segment.name = tag
self.project_tree.selectedItems()[0].setText(
0, segment.name)
def __init__(self):
pg.PlotWidget.__init__(self, enableMenu=False, )
self.getPlotItem().invertY(SETTINGS['spatialplot_invert_y_axis'])
self.getPlotItem().setAspectLocked(True, 1)
self.getPlotItem().hideAxis('left')
self.getPlotItem().hideAxis('bottom')
self.plotDataItem = self.getPlotItem().plot(pen=None, symbol='o',
symbolSize=1,
symbolBrush=(255, 255, 255),
symbolPen=(255, 255, 255))
MarkWriteMainWindow.instance().sigSelectedPenDataUpdate.connect(
self.handlePenDataSelectionChanged)
def __init__(self):
pg.PlotWidget.__init__(self, enableMenu=False)
# Create Pen Position Time Series Plot for All Data
self.getPlotItem().setLabel('left', "Pen Position", units='pix')
self.getPlotItem().setLabel('bottom', "Time", units='sec')
self.getPlotItem().getViewBox().setMouseEnabled(y=SETTINGS['timeplot_enable_ymouse'])
self.xPenPosTrace = None
self.yPenPosTrace = None
self.currentSelection = None
self.fullPenValRange=[0,1]
self.maxTime=1
self._lastselectedtimerange = None
self.sigRegionChangedProxy = None
MarkWriteMainWindow.instance().sigResetProjectData.connect(
self.handleResetPenData)
def getCurrentPenData(self):
try:
if self._level1Segment:
return self._level1Segment.pendata
except:
pass
return MarkWriteMainWindow.instance().project.pendata
def getCurrentPenData(self):
try:
if self._level1Segment:
return self._level1Segment.pendata
except:
pass
return MarkWriteMainWindow.instance().project.pendata
def handlePenDataSelectionChanged(self, timeperiod, selectedpendata):
#print ">> PenDataSpatialPlotWidget.handlePenDataSelectionChanged",timeperiod,selectedpendata.shape
if self.allPlotDataItem is None:
self.handleResetPenData(MarkWriteMainWindow.instance().project)
self.updateSelectedPenPointsGraphics(selectedpendata)
self.ensureSelectionIsVisible(timeperiod, selectedpendata)
def handlePenDataSelectionChanged(self, timeperiod, selectedpendata):
if self.allPlotDataItem is None:
self.handleResetPenData(MarkWriteMainWindow.instance().project)
self.updateSelectedPenPointsGraphics(selectedpendata)
self.ensureSelectionIsVisible(timeperiod, selectedpendata)
def addStrokeBoundaryPoints(self, strokeboundries, time_mask):
ssize = SETTINGS['pen_stroke_boundary_size']
scolor = SETTINGS['pen_stroke_boundary_color']
mpen = pg.mkPen(scolor, width=ssize)
mbrush = pg.mkBrush(scolor)
pcolor = SETTINGS['pen_stroke_pause_boundary_color']
ppen = pg.mkPen(pcolor, width=ssize)
pbrush = pg.mkBrush(pcolor)
display_x = SETTINGS['display_timeplot_xtrace']
display_y = SETTINGS['display_timeplot_ytrace']
proj = MarkWriteMainWindow.instance().project
stroke_type = proj.stroke_boundaries['stroke_type'][time_mask]
mstroke_mask = stroke_type == 0
pstroke_mask = stroke_type == 4
def addBoundaryPointsToSubPlot(plot_name, point_fields):
bpoints = self.plotitems[plot_name].get('boundary_points')
if ssize == 0:
if bpoints:
bpoints.clear()
return
if bpoints is None:
bpoints = self.plotitems[plot_name][
'boundary_points'] = pg.ScatterPlotItem(size=ssize,
pen=mpen,
brush=mbrush)
if hasattr(self, plot_name):
getattr(self, plot_name).addItem(bpoints)
else:
bpoints.clear()
for fname in point_fields:
bpoints.addPoints(x=strokeboundries['time'][mstroke_mask],
y=strokeboundries[fname][mstroke_mask],
size=ssize,
pen=mpen,
brush=mbrush)
bpoints.addPoints(x=strokeboundries['time'][pstroke_mask],
y=strokeboundries[fname][pstroke_mask],
size=ssize,
pen=ppen,
brush=pbrush)
xy_fields = []
if display_x:
xy_fields.append(X_FIELD)
if display_y:
xy_fields.append(Y_FIELD)
addBoundaryPointsToSubPlot('xy_plot', xy_fields)
if hasattr(self, 'velocity_plot'):
addBoundaryPointsToSubPlot('velocity_plot', [
'xy_velocity',
])
if hasattr(self, 'acceleration_plot'):
addBoundaryPointsToSubPlot('acceleration_plot', [
'xy_acceleration',
])
def handleSelectedObjectChanged(self, newobj, oldobj):
if MarkWriteMainWindow.instance().project.autosegl1 is True:
if isinstance(newobj, PenDataSegment):
l1seg = newobj.l1seg
if l1seg and l1seg != self._level1Segment:
self._level1Segment = l1seg
self.handleResetPenData(None)
else:
self._level1Segment = None
def mouseDoubleClickEvent(self, event):
"""
On double click, find closest pen sample to mouse pos and select
the sample's segment (if it has been assigned to one).
"""
if MarkWriteMainWindow.instance().project:
pdat = self.getCurrentPenData()
if len(pdat):
data_pos = self.getPlotItem().vb.mapSceneToView(event.pos())
dx = pdat[X_FIELD] - data_pos.x()
dy = pdat[Y_FIELD] - data_pos.y()
dxy = np.sqrt(dx * dx + dy * dy)
min_ix = dxy.argmin()
seg_id = pdat[min_ix]['segment_id']
if seg_id:
seg = PenDataSegment.id2obj[seg_id]
MarkWriteMainWindow.instance().setActiveObject(seg)
super(PenDataSpatialPlotWidget, self).mouseDoubleClickEvent(event)
def handleSelectedObjectChanged(self, newobj, oldobj):
if MarkWriteMainWindow.instance().project.autosegl1 is True:
if isinstance(newobj, PenDataSegment):
l1seg=newobj.l1seg
if l1seg and l1seg != self._level1Segment:
self._level1Segment=l1seg
self.handleResetPenData(None)
else:
self._level1Segment = None
def mouseDoubleClickEvent(self, event):
"""
On double click, find closest pen sample to mouse pos and select
the sample's segment (if it has been assigned to one).
"""
if MarkWriteMainWindow.instance().project:
pdat = self.getCurrentPenData()
if len(pdat):
data_pos = self.getPlotItem().vb.mapSceneToView(event.pos())
dx = pdat[X_FIELD]-data_pos.x()
dy = pdat[Y_FIELD]-data_pos.y()
dxy = np.sqrt(dx*dx+dy*dy)
min_ix = dxy.argmin()
seg_id = pdat[min_ix]['segment_id']
if seg_id:
seg = PenDataSegment.id2obj[seg_id]
MarkWriteMainWindow.instance().setActiveObject(seg)
super(PenDataSpatialPlotWidget,self).mouseDoubleClickEvent(event)
def handlePenDataSelectionChanged(self, timeperiod, pendata):
self._lastSelectedData = pendata
if len(pendata):
psize=SETTINGS['spatialplot_selectedpoint_size']
penarray = np.empty(pendata.shape[0], dtype=object)
brusharray = np.empty(pendata.shape[0], dtype=object)
if MarkWriteMainWindow.instance().project.isSelectedDataValidForNewSegment():
penarray[:] = self.qtpenbrushs['selected_valid_pressed_pen']
penarray[pendata['pressure'] == 0] = self.qtpenbrushs['selected_valid_hover_pen']
brusharray[:] = self.qtpenbrushs['selected_valid_pressed_brush']
brusharray[pendata['pressure'] == 0] = self.qtpenbrushs['selected_valid_hover_brush']
else:
penarray[:] = self.qtpenbrushs['selected_invalid_pressed_pen']
penarray[pendata['pressure'] == 0] = self.qtpenbrushs['selected_invalid_hover_pen']
brusharray[:] = self.qtpenbrushs['selected_invalid_pressed_brush']
brusharray[pendata['pressure'] == 0] = self.qtpenbrushs['selected_invalid_hover_brush']
self.plotDataItem.setData(x=pendata[X_FIELD],
y=pendata[Y_FIELD], pen=None,
symbol='o', symbolSize=psize,
symbolBrush=brusharray, symbolPen=penarray)
ssize = SETTINGS['pen_stroke_boundary_size']
if self.strokeBoundaryPoints is None:
if ssize > 0:
self.strokeBoundaryPoints = pg.ScatterPlotItem(size=ssize, pen=self.qtpenbrushs['stroke_boundary_pen'], brush=self.qtpenbrushs['stroke_boundary_brush'])
self.getPlotItem().addItem(self.strokeBoundaryPoints)
else:
if ssize == 0:
self.strokeBoundaryPoints.clear()
else:
proj = MarkWriteMainWindow.instance().project
pstart, pend = pendata['time'][[0,-1]]
vms_times = proj.stroke_boundary_samples['time']
vmpoints = proj.stroke_boundary_samples[(vms_times >= pstart) & (vms_times <= pend)]
self.strokeBoundaryPoints.setData(x=vmpoints[X_FIELD], y=vmpoints[Y_FIELD], size=ssize, pen=self.qtpenbrushs['stroke_boundary_pen'], brush=self.qtpenbrushs['stroke_boundary_brush'])
else:
self.plotDataItem.clear()#setData(x=[],y=[],pen='black', brush='')
self.getPlotItem().enableAutoRange(x=True, y=True)
def handleResetPenData(self, project):
#print ">> ### PenDataSpatialPlotWidget.handleResetPenData:",project
#pdat = project.pendata
pdat = self.getCurrentPenData()
if self.allPlotDataItem is None:
brusharray, penarray = self.createDefaultPenBrushForData(pdat)
self.allPlotDataItem = self.getPlotItem().plot(
x=pdat[X_FIELD],
y=pdat[Y_FIELD],
pen=None,
symbol='o',
symbolSize=1,
symbolBrush=brusharray,
symbolPen=penarray)
pen = pg.mkPen(SETTINGS['spatialplot_selectedvalid_color'],
width=SETTINGS['spatialplot_selectedpoint_size'])
brush = pg.mkBrush(SETTINGS['spatialplot_selectedvalid_color'])
self.selectedPlotDataItem = self.getPlotItem().plot(
pen=None,
symbol='o',
symbolSize=SETTINGS['spatialplot_selectedpoint_size'],
symbolPen=pen,
symbolBrush=brush)
else:
brusharray, penarray = self.createDefaultPenBrushForData(pdat)
self.allPlotDataItem.setData(x=pdat[X_FIELD],
y=pdat[Y_FIELD],
pen=None,
symbol='o',
symbolSize=1,
symbolBrush=brusharray,
symbolPen=penarray)
self.getPlotItem().setLimits(xMin=pdat[X_FIELD].min() - 10,
yMin=pdat[Y_FIELD].min() - 10,
xMax=pdat[X_FIELD].max() + 10,
yMax=pdat[Y_FIELD].max() + 10)
self.setRange(xRange=(pdat[X_FIELD].min() - 10,
pdat[X_FIELD].max() + 10),
yRange=(pdat[Y_FIELD].min() - 10,
pdat[Y_FIELD].max() + 10),
padding=None)
proj = MarkWriteMainWindow.instance().project
pstart, pend = pdat['time'][[0, -1]]
vms_times = proj.stroke_boundary_samples['time']
vms_mask = (vms_times >= pstart) & (vms_times <= pend)
self.addStrokeBoundaryPoints(proj.stroke_boundary_samples[vms_mask],
vms_mask)
def updateSelectedPenPointsGraphics(self, selectedpendata=None):
if selectedpendata is None:
selectedpendata = MarkWriteMainWindow.instance(
).project.selectedpendata
pen = pen2 = None
brush = brush2 = None
psize = SETTINGS['spatialplot_selectedpoint_size']
if MarkWriteMainWindow.instance(
).project.isSelectedDataValidForNewSegment():
pen = pg.mkPen(SETTINGS['spatialplot_selectedvalid_color'],
width=SETTINGS['spatialplot_selectedpoint_size'])
pen2 = pg.mkPen(
SETTINGS['spatialplot_selectedvalid_color'].darker(300),
width=SETTINGS['spatialplot_selectedpoint_size'])
brush = pg.mkBrush(SETTINGS['spatialplot_selectedvalid_color'])
brush2 = pg.mkBrush(
SETTINGS['spatialplot_selectedvalid_color'].darker(300))
else:
pen = pg.mkPen(SETTINGS['spatialplot_selectedinvalid_color'],
width=SETTINGS['spatialplot_selectedpoint_size'])
brush = pg.mkBrush(SETTINGS['spatialplot_selectedinvalid_color'])
pen2 = pg.mkPen(
SETTINGS['spatialplot_selectedinvalid_color'].darker(300),
width=SETTINGS['spatialplot_selectedpoint_size'])
brush2 = pg.mkBrush(
SETTINGS['spatialplot_selectedinvalid_color'].darker(300))
penarray = np.empty(selectedpendata.shape[0], dtype=object)
penarray[:] = pen
penarray[selectedpendata['pressure'] == 0] = pen2
brusharray = np.empty(selectedpendata.shape[0], dtype=object)
brusharray[:] = brush
brusharray[selectedpendata['pressure'] == 0] = brush2
self.selectedPlotDataItem.setData(x=selectedpendata[X_FIELD],
y=selectedpendata[Y_FIELD],
pen=None,
symbol='o',
symbolSize=psize,
symbolBrush=brusharray,
symbolPen=penarray)
def handleUpdatedSettingsEvent(self, updates, settings):
selectedpendata = MarkWriteMainWindow.instance().project.selectedpendata
pdat = MarkWriteMainWindow.instance().project.pendata
for k in updates.keys():
if k.startswith('spatialplot_default'):
brusharray, penarray = self.createDefaultPenBrushForData(pdat)
self.allPlotDataItem.setData(x=pdat['x'], y=pdat['y'],
symbolBrush=brusharray,
symbolPen=penarray)
break
for k in updates.keys():
if k.startswith('spatialplot_selected'):
self.updateSelectedPenPointsGraphics(selectedpendata)
break
if 'spatialplot_invert_y_axis' in updates.keys():
self.getPlotItem().invertY(SETTINGS['spatialplot_invert_y_axis'])
def currentTreeItemChangedEvent(self, *args, **kwargs):
current_tree_item, old_tree_widget = args
#print ">> currentTreeItemChangedEvent:",current_tree_item, old_tree_widget
# print " selected items:",self.project_tree.selectedItems()
try:
if current_tree_item is None:
#passing in not obj sets activeObject to project.selectedtimeregion
MarkWriteMainWindow.instance().setActiveObject()
elif self.doNotSetActiveObject is False:
self.project_tree.setCurrentItem(current_tree_item)
selectedsegment = current_tree_item._pydat
if selectedsegment.isRoot():
ao=MarkWriteMainWindow.instance().setActiveObject()
else:
ao=MarkWriteMainWindow.instance().setActiveObject(selectedsegment)
#print "Set active object:",ao
except Exception, e:
#import traceback
#traceback.print_exc()
self.properties_table.clear()
def handleSelectedObjectChanged(self, newobj, oldobj):
if MarkWriteMainWindow.instance().project.autosegl1 is True:
if isinstance(newobj, PenDataSegment):
l1seg = newobj.l1seg
if l1seg and l1seg != self._level1Segment:
#print ">> *** PenDataSpatialPlotWidget.handleSelectedObjectChanged:",l1seg
self._level1Segment = l1seg
self.handleResetPenData(None)
#print "<< *** PenDataSpatialPlotWidget.handleSelectedObjectChanged"
else:
self._level1Segment = None
def currentTreeItemChangedEvent(self, *args, **kwargs):
current_tree_item, old_tree_widget = args
#print ">> currentTreeItemChangedEvent:",current_tree_item, old_tree_widget
# print " selected items:",self.project_tree.selectedItems()
try:
if current_tree_item is None:
#passing in not obj sets activeObject to project.selectedtimeregion
MarkWriteMainWindow.instance().setActiveObject()
elif self.doNotSetActiveObject is False:
self.project_tree.setCurrentItem(current_tree_item)
selectedsegment = current_tree_item._pydat
if selectedsegment.isRoot():
ao = MarkWriteMainWindow.instance().setActiveObject()
else:
ao = MarkWriteMainWindow.instance().setActiveObject(
selectedsegment)
#print "Set active object:",ao
except Exception, e:
#import traceback
#traceback.print_exc()
self.properties_table.clear()
def updateSelectedPenPointsGraphics(self, selectedpendata=None):
if selectedpendata is None:
selectedpendata = MarkWriteMainWindow.instance().project.selectedpendata
if MarkWriteMainWindow.instance().project.isSelectedDataValidForNewSegment():
pen = pg.mkPen(SETTINGS['spatialplot_selectedvalid_color'],
width=SETTINGS['spatialplot_selectedpoint_size'])
brush = pg.mkBrush(SETTINGS['spatialplot_selectedvalid_color'])
self.selectedPlotDataItem.setData(x=selectedpendata['x'],
y=selectedpendata['y'], pen=None,
symbol='o', symbolSize=SETTINGS[
'spatialplot_selectedpoint_size'],
symbolBrush=brush, symbolPen=pen)
else:
pen = pg.mkPen(SETTINGS['spatialplot_selectedinvalid_color'],
width=SETTINGS['spatialplot_selectedpoint_size'])
brush = pg.mkBrush(SETTINGS['spatialplot_selectedinvalid_color'])
self.selectedPlotDataItem.setData(x=selectedpendata['x'],
y=selectedpendata['y'], pen=None,
symbol='o', symbolSize=SETTINGS[
'spatialplot_selectedpoint_size'],
symbolBrush=brush, symbolPen=pen)
def handleSelectedObjectChanged(self, newobj, oldobj):
if MarkWriteMainWindow.instance().project.autosegl1 is True:
if isinstance(newobj, PenDataSegment):
l1seg=newobj.l1seg
if l1seg and l1seg != self._level1Segment:
#print ">> *** PenDataSpatialPlotWidget.handleSelectedObjectChanged:",l1seg
self._level1Segment=l1seg
self.handleResetPenData(None)
#print "<< *** PenDataSpatialPlotWidget.handleSelectedObjectChanged"
else:
self._level1Segment = None
def handleUpdatedSettingsEvent(self, updates, settings):
penarray, brusharray = None, None
penpoints = MarkWriteMainWindow.instance().project.pendata
for k in updates.keys():
if k.startswith('timeplot_xtrace'):
penarray, brusharray = self.updateTraceX(penpoints, penarray, brusharray)
break
for k in updates.keys():
if k.startswith('timeplot_ytrace'):
self.updateTraceY(penpoints, penarray, brusharray)
break
self.getPlotItem().getViewBox().setMouseEnabled(y=SETTINGS['timeplot_enable_ymouse'])
if SETTINGS['timeplot_enable_ymouse'] is False:
self.setRange(yRange=self.fullPenValRange)
def handleResetPenData(self, project):
#print ">> ### PenDataSpatialPlotWidget.handleResetPenData:",project
#pdat = project.pendata
pdat = self.getCurrentPenData()
if self.allPlotDataItem is None:
brusharray,penarray = self.createDefaultPenBrushForData(pdat)
self.allPlotDataItem = self.getPlotItem().plot(x=pdat[X_FIELD],
y=pdat[Y_FIELD],
pen=None, symbol='o',
symbolSize=1,
symbolBrush=brusharray,
symbolPen=penarray)
pen = pg.mkPen(SETTINGS['spatialplot_selectedvalid_color'], width=SETTINGS['spatialplot_selectedpoint_size'])
brush = pg.mkBrush(SETTINGS['spatialplot_selectedvalid_color'])
self.selectedPlotDataItem = self.getPlotItem().plot(pen=None,
symbol='o',
symbolSize=SETTINGS['spatialplot_selectedpoint_size'],
symbolPen=pen,
symbolBrush=brush)
else:
brusharray, penarray = self.createDefaultPenBrushForData(pdat)
self.allPlotDataItem.setData(x=pdat[X_FIELD], y=pdat[Y_FIELD],
pen=None, symbol='o',
symbolSize=1,
symbolBrush=brusharray,
symbolPen=penarray)
self.getPlotItem().setLimits(xMin=pdat[X_FIELD].min(),
yMin=pdat[Y_FIELD].min(),
xMax=pdat[X_FIELD].max(),
yMax=pdat[Y_FIELD].max())
self.setRange(xRange=(pdat[X_FIELD].min(), pdat[X_FIELD].max()),
yRange=(pdat[Y_FIELD].min(), pdat[Y_FIELD].max()),
padding=None)
proj = MarkWriteMainWindow.instance().project
pstart, pend = pdat['time'][[0,-1]]
vms_times = proj.stroke_boundary_samples['time']
vms_mask = (vms_times >= pstart) & (vms_times <= pend)
self.addStrokeBoundaryPoints(proj.stroke_boundary_samples[vms_mask])
def __init__(self):
DockArea.__init__(self)
self.project_tree_dock = Dock(u"Project Tree", hideTitle=True)
self.addDock(self.project_tree_dock,
'top') #'above', self.flowcharts_dock)
self.project_tree = SegmentTreeWidget()
self.project_tree_dock.addWidget(self.project_tree)
self.properties_table = TableWidget(sortable=False, editable=False)
self.properties_table.setFormat("%.3f",1)
self.properties_table.setColumnCount(1)
self.properties_table.contextMenu.clear()
self.properties_table.horizontalHeader().hide()
self.properties_dock = Dock("Selected Object Properties",
widget=self.properties_table,
hideTitle=True)
self.addDock(self.properties_dock, 'bottom')
MarkWriteMainWindow.instance().sigProjectChanged.connect(
self.handleProjectChange)
MarkWriteMainWindow.instance().sigSegmentCreated.connect(
self.handleSegmentCreated)
MarkWriteMainWindow.instance().sigSegmentRemoved.connect(
self.handleSegmentRemoved)
MarkWriteMainWindow.instance().sigActiveObjectChanged.connect(
self.handleActiveObjectChanged)
self.project_tree.currentItemChanged.connect(
self.currentTreeItemChangedEvent)
self.project_tree.itemDoubleClicked.connect(
self.treeItemDoubleClickedEvent)
self.project_tree.customContextMenuRequested.connect(
self.rightClickTreeEvent)
# self.project_tree.itemSelectionChanged.connect(self.handleItemSelectionChanged)
self.project_tree.setExpandsOnDoubleClick(False)
self.doNotSetActiveObject=False
def __init__(self):
DockArea.__init__(self)
self.project_tree_dock = Dock(u"Project Tree", hideTitle=True)
self.addDock(self.project_tree_dock,
'top') #'above', self.flowcharts_dock)
self.project_tree = SegmentTreeWidget()
self.project_tree_dock.addWidget(self.project_tree)
self.properties_table = TableWidget(sortable=False, editable=False)
self.properties_table.setFormat("%.3f", 1)
self.properties_table.setColumnCount(1)
self.properties_table.contextMenu.clear()
self.properties_table.horizontalHeader().hide()
self.properties_dock = Dock("Selected Object Properties",
widget=self.properties_table,
hideTitle=True)
self.addDock(self.properties_dock, 'bottom')
MarkWriteMainWindow.instance().sigProjectChanged.connect(
self.handleProjectChange)
MarkWriteMainWindow.instance().sigSegmentCreated.connect(
self.handleSegmentCreated)
MarkWriteMainWindow.instance().sigSegmentRemoved.connect(
self.handleSegmentRemoved)
MarkWriteMainWindow.instance().sigActiveObjectChanged.connect(
self.handleActiveObjectChanged)
self.project_tree.currentItemChanged.connect(
self.currentTreeItemChangedEvent)
self.project_tree.itemDoubleClicked.connect(
self.treeItemDoubleClickedEvent)
self.project_tree.customContextMenuRequested.connect(
self.rightClickTreeEvent)
# self.project_tree.itemSelectionChanged.connect(self.handleItemSelectionChanged)
self.project_tree.setExpandsOnDoubleClick(False)
self.doNotSetActiveObject = False
def __init__(self):
pg.PlotWidget.__init__(self, enableMenu=False)
self.getPlotItem().invertY(SETTINGS['spatialplot_invert_y_axis'])
self.getPlotItem().setAspectLocked(True, 1)
self.allPlotDataItem = None #self.getPlotItem().plot(pen=None,
# symbol='o', symbolSize=1, symbolBrush=(255,255,255), symbolPen=(
# 255,255,255))
self.selectedPlotDataItem = None #self.getPlotItem().plot(pen=None,
# symbol='o', symbolSize=3, symbolBrush=(0,0,255), symbolPen=(0,0,255))
MarkWriteMainWindow.instance().sigResetProjectData.connect(
self.handleResetPenData)
MarkWriteMainWindow.instance().sigSelectedPenDataUpdate.connect(
self.handlePenDataSelectionChanged)
MarkWriteMainWindow.instance().sigSegmentRemoved.connect(
self.handleSegmentRemoved)
MarkWriteMainWindow.instance().sigSegmentCreated.connect(
self.handleSegmentCreated)
def __init__(self):
pg.PlotWidget.__init__(self, enableMenu=False)
self._level1Segment=None
self.getPlotItem().invertY(SETTINGS['spatialplot_invert_y_axis'])
self.getPlotItem().setAspectLocked(True, 1)
self.getPlotItem().setContentsMargins(5, 5, 5, 5)
self.allPlotDataItem = None
self.selectedPlotDataItem = None
self.strokeBoundaryPoints = None
self._enablePopupDisplay = True
MarkWriteMainWindow.instance().sigResetProjectData.connect(
self.handleResetPenData)
MarkWriteMainWindow.instance().sigSegmentRemoved.connect(
self.handleSegmentRemoved)
MarkWriteMainWindow.instance().sigSegmentCreated.connect(
self.handleSegmentCreated)
MarkWriteMainWindow.instance().sigActiveObjectChanged.connect(
self.handleSelectedObjectChanged)
def __init__(self):
pg.PlotWidget.__init__(self, enableMenu=False)
self._level1Segment = None
self.getPlotItem().invertY(SETTINGS['spatialplot_invert_y_axis'])
self.getPlotItem().setAspectLocked(True, 1)
self.getPlotItem().setContentsMargins(5, 5, 5, 5)
self.allPlotDataItem = None
self.selectedPlotDataItem = None
self.strokeBoundaryPoints = None
self._enablePopupDisplay = True
MarkWriteMainWindow.instance().sigResetProjectData.connect(
self.handleResetPenData)
MarkWriteMainWindow.instance().sigSegmentRemoved.connect(
self.handleSegmentRemoved)
MarkWriteMainWindow.instance().sigSegmentCreated.connect(
self.handleSegmentCreated)
MarkWriteMainWindow.instance().sigActiveObjectChanged.connect(
self.handleSelectedObjectChanged)
def addStrokeBoundaryPoints(self, strokeboundries, time_filter):
ssize = SETTINGS['pen_stroke_boundary_size']
if ssize == 0:
if self.strokeBoundaryPoints:
self.strokeBoundaryPoints.clear()
return
proj = MarkWriteMainWindow.instance().project
stroke_type = proj.stroke_boundaries['stroke_type'][time_filter]
pcolor = SETTINGS['pen_stroke_pause_boundary_color']
scolor = SETTINGS['pen_stroke_boundary_color']
pen = pg.mkPen(scolor, width=ssize)
brush = pg.mkBrush(scolor)
if self.strokeBoundaryPoints is None:
self.strokeBoundaryPoints = pg.ScatterPlotItem(size=ssize,
pen=pen,
brush=brush)
self.getPlotItem().addItem(self.strokeBoundaryPoints)
else:
self.strokeBoundaryPoints.clear()
mstrokes = stroke_type == 0
self.strokeBoundaryPoints.addPoints(
x=strokeboundries[X_FIELD][mstrokes],
y=strokeboundries[Y_FIELD][mstrokes],
size=ssize,
pen=pen,
brush=brush)
pen = pg.mkPen(pcolor, width=ssize)
brush = pg.mkBrush(pcolor)
pstrokes = stroke_type == 4
self.strokeBoundaryPoints.addPoints(
x=strokeboundries[X_FIELD][pstrokes],
y=strokeboundries[Y_FIELD][pstrokes],
size=ssize,
pen=pen,
brush=brush)
def treeItemDoubleClickedEvent(self, *args, **kwargs):
selectedsegment = args[0]._pydat
MarkWriteMainWindow.instance()._penDataTimeLineWidget.zoomToPenData(
selectedsegment.pendata)
MarkWriteMainWindow.instance()._penDataSpatialViewWidget.zoomToPenData(
selectedsegment.pendata)
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import markwrite
import sys
if sys.platform == 'win32':
# Work around so that MarkWrite app icon is also used as task bar icon.
# http://stackoverflow.com/questions/1551605/how-to-set-applications-taskbar-icon-in-windows-7/1552105#1552105
import ctypes
myappid = u'isolver.markwrite.editor.version' # arbitrary string
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
import pyqtgraph as pg
from markwrite.gui.mainwin import MarkWriteMainWindow
# # Switch to using white background and black foreground
pg.setConfigOption('background',
markwrite.SETTINGS['plotviews_background_color'])
pg.setConfigOption('foreground',
markwrite.SETTINGS['plotviews_foreground_color'])
wmwin = MarkWriteMainWindow(markwrite.app)
MarkWriteMainWindow._appdirs = markwrite.appdirs
wmwin.show()
status = markwrite.app.exec_()
def treeItemDoubleClickedEvent(self, *args, **kwargs):
selectedsegment = args[0]._pydat
MarkWriteMainWindow.instance()._penDataTimeLineWidget.zoomToPenData(
selectedsegment.pendata)
MarkWriteMainWindow.instance()._penDataSpatialViewWidget.zoomToPenData(
selectedsegment.pendata)
def handlePenDataSelectionChanged(self, timeperiod, pendata):
self._lastSelectedData = pendata
if len(pendata):
psize = SETTINGS['spatialplot_selectedpoint_size']
penarray = np.empty(pendata.shape[0], dtype=object)
brusharray = np.empty(pendata.shape[0], dtype=object)
if MarkWriteMainWindow.instance(
).project.isSelectedDataValidForNewSegment():
penarray[:] = self.qtpenbrushs['selected_valid_pressed_pen']
penarray[pendata['pressure'] ==
0] = self.qtpenbrushs['selected_valid_hover_pen']
brusharray[:] = self.qtpenbrushs[
'selected_valid_pressed_brush']
brusharray[pendata['pressure'] ==
0] = self.qtpenbrushs['selected_valid_hover_brush']
else:
penarray[:] = self.qtpenbrushs['selected_invalid_pressed_pen']
penarray[pendata['pressure'] ==
0] = self.qtpenbrushs['selected_invalid_hover_pen']
brusharray[:] = self.qtpenbrushs[
'selected_invalid_pressed_brush']
brusharray[pendata['pressure'] == 0] = self.qtpenbrushs[
'selected_invalid_hover_brush']
self.plotDataItem.setData(x=pendata[X_FIELD],
y=pendata[Y_FIELD],
pen=None,
symbol='o',
symbolSize=psize,
symbolBrush=brusharray,
symbolPen=penarray)
ssize = SETTINGS['pen_stroke_boundary_size']
if self.strokeBoundaryPoints is None:
if ssize > 0:
self.strokeBoundaryPoints = pg.ScatterPlotItem(
size=ssize,
pen=self.qtpenbrushs['stroke_boundary_pen'],
brush=self.qtpenbrushs['stroke_boundary_brush'])
self.getPlotItem().addItem(self.strokeBoundaryPoints)
self.strokeBoundaryPoints.clear()
if ssize > 0:
proj = MarkWriteMainWindow.instance().project
pstart, pend = pendata['time'][[0, -1]]
vms_times = proj.stroke_boundary_samples['time']
time_filter = (vms_times >= pstart) & (vms_times <= pend)
stroke_type = proj.stroke_boundaries['stroke_type'][
time_filter]
mstrokes = stroke_type == 0
vmpoints = proj.stroke_boundary_samples[time_filter]
if len(vmpoints) > 0:
self.strokeBoundaryPoints.addPoints(
x=vmpoints[X_FIELD][mstrokes],
y=vmpoints[Y_FIELD][mstrokes],
size=ssize,
pen=self.qtpenbrushs['stroke_boundary_pen'],
brush=self.qtpenbrushs['stroke_boundary_brush'])
pstrokes = stroke_type == 4
self.strokeBoundaryPoints.addPoints(
x=vmpoints[X_FIELD][pstrokes],
y=vmpoints[Y_FIELD][pstrokes],
size=ssize,
pen=self.qtpenbrushs['pause_boundary_pen'],
brush=self.qtpenbrushs['pause_boundary_brush'])
else:
self.plotDataItem.clear(
) #setData(x=[],y=[],pen='black', brush='')
self.getPlotItem().enableAutoRange(x=True, y=True)
def handleResetPenData(self, project):
'''
:param self:
:param project:
:return:
'''
#penpoints = project.pendata
penpoints = self.getCurrentPenData()
self.fullPenValRange = (min(penpoints[X_FIELD].min(),
penpoints[Y_FIELD].min()),
max(penpoints[X_FIELD].max(),
penpoints[Y_FIELD].max()))
self.maxTime = penpoints['time'][-1]
self.xy_plot.setLimits(yMin=self.fullPenValRange[0],
yMax=self.fullPenValRange[1],
xMin=penpoints['time'][0],
xMax=penpoints['time'][-1])
penarray, brusharray = None, None
# Create DataItem objects
penarray, brusharray = self.getPenBrush('timeplot_xtrace_color',
'timeplot_xtrace_size',
penpoints, penarray,
brusharray)
self.addPlotLineItem('xy_plot',
'x',
x=penpoints['time'],
y=penpoints[X_FIELD],
symbolPen=penarray,
symbolBrush=brusharray,
pen=None,
symbol='o',
symbolSize=SETTINGS['timeplot_xtrace_size'])
self.plotitems['xy_plot']['x'].setVisible(
SETTINGS['display_timeplot_xtrace'])
penarray, brusharray = self.getPenBrush('timeplot_ytrace_color',
'timeplot_ytrace_size',
penpoints, penarray,
brusharray)
added = self.addPlotLineItem(
'xy_plot',
'y',
x=penpoints['time'],
y=penpoints[Y_FIELD],
pen=None,
symbol='o',
symbolSize=SETTINGS['timeplot_ytrace_size'],
symbolPen=penarray,
symbolBrush=brusharray)
self.plotitems['xy_plot']['y'].setVisible(
SETTINGS['display_timeplot_ytrace'])
if hasattr(self, 'velocity_plot'):
penarray, brusharray = self.getPenBrush('timeplot_vtrace_color',
'timeplot_vtrace_size',
penpoints, penarray,
brusharray)
added = self.addPlotLineItem(
'velocity_plot',
'xy_velocity',
x=penpoints['time'],
y=penpoints['xy_velocity'],
pen=None,
symbol='o',
symbolSize=SETTINGS['timeplot_vtrace_size'],
symbolPen=penarray,
symbolBrush=brusharray)
self.velocity_plot.setLimits(xMin=penpoints['time'][0],
xMax=penpoints['time'][-1])
if hasattr(self, 'acceleration_plot'):
penarray, brusharray = self.getPenBrush('timeplot_atrace_color',
'timeplot_atrace_size',
penpoints, penarray,
brusharray)
added = self.addPlotLineItem(
'acceleration_plot',
'xy_acceleration',
x=penpoints['time'],
y=penpoints['xy_acceleration'],
pen=None,
symbol='o',
symbolSize=SETTINGS['timeplot_atrace_size'],
symbolPen=penarray,
symbolBrush=brusharray)
self.acceleration_plot.setLimits(xMin=penpoints['time'][0],
xMax=penpoints['time'][-1])
if added:
# Add a Selection Region that is used to create segments by user
# The project class now creates the selection region item widget
self.currentSelection = project.selectedtimeregion
self.xy_plot.addItem(self.currentSelection)
else:
self.xy_plot.getViewBox().setMouseEnabled(
y=SETTINGS['timeplot_enable_ymouse'])
# Update DataItem objects
penarray, brusharray = self.updateTrace('xy_plot', 'x',
'timeplot_xtrace_color',
'timeplot_xtrace_size',
penpoints, penarray,
brusharray)
penarray, brusharray = self.updateTrace('xy_plot', 'y',
'timeplot_ytrace_color',
'timeplot_ytrace_size',
penpoints, penarray,
brusharray)
if hasattr(self, 'velocity_plot'):
penarray, brusharray = self.updateTrace(
'velocity_plot', 'xy_velocity', 'timeplot_vtrace_color',
'timeplot_vtrace_size', penpoints, penarray, brusharray)
if hasattr(self, 'acceleration_plot'):
penarray, brusharray = self.updateTrace(
'acceleration_plot', 'xy_acceleration',
'timeplot_atrace_color', 'timeplot_atrace_size', penpoints,
penarray, brusharray)
proj = MarkWriteMainWindow.instance().project
pstart, pend = penpoints['time'][[0, -1]]
vms_times = proj.stroke_boundary_samples['time']
vms_mask = (vms_times >= pstart) & (vms_times <= pend)
self.addStrokeBoundaryPoints(proj.stroke_boundary_samples[vms_mask],
vms_mask)
self.xy_plot.setRange(xRange=(penpoints['time'][0],
penpoints['time'][-1]),
yRange=self.fullPenValRange,
padding=None)
def handleUpdatedSettingsEvent(self, updates, settings):
penarray, brusharray = None, None
penpoints = self.getCurrentPenData()
for k in updates.keys():
if k.startswith('timeplot_xtrace'):
penarray, brusharray = self.updateTrace(
'xy_plot', 'x', 'timeplot_xtrace_color',
'timeplot_xtrace_size', penpoints, penarray, brusharray)
break
for k in updates.keys():
if k.startswith('timeplot_ytrace'):
self.updateTrace('xy_plot', 'y', 'timeplot_ytrace_color',
'timeplot_ytrace_size', penpoints, penarray,
brusharray)
break
prev_bottom_plot = self.bottom_plot
if 'display_timeplot_atrace' in updates.keys():
plot_currently_displayed = hasattr(
self,
'acceleration_plot') and self.acceleration_plot is not None
if plot_currently_displayed and updates[
'display_timeplot_atrace'] is False:
self.removeAccelerationPlot()
elif not plot_currently_displayed and updates[
'display_timeplot_atrace'] is True:
self.createAccelerationPlot(SETTINGS['timeplot_enable_ymouse'])
penarray, brusharray = self.updateTrace(
'acceleration_plot', 'xy_acceleration',
'timeplot_atrace_color', 'timeplot_atrace_size', penpoints,
penarray, brusharray)
else:
if hasattr(self, 'acceleration_plot'):
for k in updates.keys():
if k.startswith('timeplot_atrace'):
penarray, brusharray = self.updateTrace(
'acceleration_plot', 'xy_acceleration',
'timeplot_atrace_color', 'timeplot_atrace_size',
penpoints, penarray, brusharray)
break
if 'display_timeplot_xtrace' in updates.keys():
self.plotitems['xy_plot']['x'].setVisible(
SETTINGS['display_timeplot_xtrace'])
if 'display_timeplot_ytrace' in updates.keys():
self.plotitems['xy_plot']['y'].setVisible(
SETTINGS['display_timeplot_ytrace'])
if 'display_timeplot_vtrace' in updates.keys():
plot_currently_displayed = hasattr(
self, 'velocity_plot') and self.velocity_plot is not None
if plot_currently_displayed and updates[
'display_timeplot_vtrace'] is False:
self.removeVelocityPlot()
elif not plot_currently_displayed and updates[
'display_timeplot_vtrace'] is True:
self.createVelocityPlot(SETTINGS['timeplot_enable_ymouse'])
penarray, brusharray = self.updateTrace(
'velocity_plot', 'xy_velocity', 'timeplot_vtrace_color',
'timeplot_vtrace_size', penpoints, penarray, brusharray)
else:
if hasattr(self, 'velocity_plot'):
for k in updates.keys():
if k.startswith('timeplot_vtrace'):
penarray, brusharray = self.updateTrace(
'velocity_plot', 'xy_velocity',
'timeplot_vtrace_color', 'timeplot_vtrace_size',
penpoints, penarray, brusharray)
break
if self.bottom_plot != prev_bottom_plot:
prev_bottom_plot.hideAxis('bottom')
self.bottom_plot.setLabel('bottom', text="Time", units='sec')
for k in updates.keys():
if k.startswith('pen_stroke_boundary') or k.startswith(
'display_timeplot_xtrace') or k.startswith(
'display_timeplot_ytrace'):
proj = MarkWriteMainWindow.instance().project
pstart, pend = penpoints['time'][[0, -1]]
vms_times = proj.stroke_boundary_samples['time']
vms_mask = (vms_times >= pstart) & (vms_times <= pend)
self.addStrokeBoundaryPoints(
proj.stroke_boundary_samples[vms_mask], vms_mask)
break
self.xy_plot.getViewBox().setMouseEnabled(
y=SETTINGS['timeplot_enable_ymouse'])
if SETTINGS['timeplot_enable_ymouse'] is False:
self.xy_plot.setRange(yRange=self.fullPenValRange)
def handleResetPenData(self, project):
'''
:param self:
:param project:
:return:
'''
#penpoints = project.pendata
penpoints = self.getCurrentPenData()
self.fullPenValRange = (min(penpoints[X_FIELD].min(), penpoints[Y_FIELD].min()),
max(penpoints[X_FIELD].max(), penpoints[Y_FIELD].max()))
self.maxTime=penpoints['time'][-1]
self.xy_plot.setLimits(yMin=self.fullPenValRange[0], yMax=self.fullPenValRange[1],
xMin=penpoints['time'][0],
xMax=penpoints['time'][-1])
penarray, brusharray = None, None
# Create DataItem objects
penarray, brusharray = self.getPenBrush('timeplot_xtrace_color', 'timeplot_xtrace_size',penpoints, penarray,
brusharray)
self.addPlotLineItem('xy_plot','x',x=penpoints['time'],
y=penpoints[X_FIELD],
symbolPen=penarray,
symbolBrush=brusharray,
pen=None, symbol='o',
symbolSize=SETTINGS['timeplot_xtrace_size'])
self.plotitems['xy_plot']['x'].setVisible(SETTINGS['display_timeplot_xtrace'])
penarray, brusharray = self.getPenBrush('timeplot_ytrace_color', 'timeplot_ytrace_size',penpoints, penarray,
brusharray)
added = self.addPlotLineItem('xy_plot','y',x=penpoints['time'],
y=penpoints[Y_FIELD],
pen=None, symbol='o',
symbolSize=SETTINGS[
'timeplot_ytrace_size'],
symbolPen=penarray,
symbolBrush=brusharray)
self.plotitems['xy_plot']['y'].setVisible(SETTINGS['display_timeplot_ytrace'])
if hasattr(self, 'velocity_plot'):
penarray, brusharray = self.getPenBrush('timeplot_vtrace_color', 'timeplot_vtrace_size',penpoints, penarray,
brusharray)
added = self.addPlotLineItem('velocity_plot','xy_velocity',x=penpoints['time'],
y=penpoints['xy_velocity'],
pen=None, symbol='o',
symbolSize=SETTINGS[
'timeplot_vtrace_size'],
symbolPen=penarray,
symbolBrush=brusharray)
self.velocity_plot.setLimits(xMin=penpoints['time'][0],
xMax=penpoints['time'][-1])
if hasattr(self, 'acceleration_plot'):
penarray, brusharray = self.getPenBrush('timeplot_atrace_color', 'timeplot_atrace_size',penpoints, penarray,
brusharray)
added = self.addPlotLineItem('acceleration_plot','xy_acceleration',x=penpoints['time'],
y=penpoints['xy_acceleration'],
pen=None, symbol='o',
symbolSize=SETTINGS[
'timeplot_atrace_size'],
symbolPen=penarray,
symbolBrush=brusharray)
self.acceleration_plot.setLimits(xMin=penpoints['time'][0],
xMax=penpoints['time'][-1])
if added:
# Add a Selection Region that is used to create segments by user
# The project class now creates the selection region item widget
self.currentSelection = project.selectedtimeregion
self.xy_plot.addItem(self.currentSelection)
else:
self.xy_plot.getViewBox().setMouseEnabled(y=SETTINGS['timeplot_enable_ymouse'])
# Update DataItem objects
penarray, brusharray = self.updateTrace('xy_plot','x','timeplot_xtrace_color', 'timeplot_xtrace_size', penpoints, penarray, brusharray)
penarray, brusharray = self.updateTrace('xy_plot','y','timeplot_ytrace_color', 'timeplot_ytrace_size',penpoints, penarray, brusharray)
if hasattr(self, 'velocity_plot'):
penarray, brusharray = self.updateTrace('velocity_plot','xy_velocity','timeplot_vtrace_color', 'timeplot_vtrace_size',penpoints, penarray, brusharray)
if hasattr(self, 'acceleration_plot'):
penarray, brusharray = self.updateTrace('acceleration_plot','xy_acceleration','timeplot_atrace_color', 'timeplot_atrace_size',penpoints, penarray, brusharray)
proj = MarkWriteMainWindow.instance().project
pstart, pend = penpoints['time'][[0,-1]]
vms_times = proj.stroke_boundary_samples['time']
vms_mask = (vms_times >= pstart) & (vms_times <= pend)
self.addStrokeBoundaryPoints(proj.stroke_boundary_samples[vms_mask])
self.xy_plot.setRange(xRange=(penpoints['time'][0], penpoints['time'][-1]),
yRange=self.fullPenValRange,
padding=None)
myappid = u'isolver.markwrite.editor.version' # arbitrary string
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
# Need to import pyTables module before pyqt imports pyh5 or error occurs when
# openning an iohub datastore file.
import tables
import pyqtgraph as pg
# # Switch to using white background and black foreground
from pyqtgraph.Qt import QtGui
from markwrite.gui.mainwin import MarkWriteMainWindow
from markwrite.appdirs import AppDirs
from markwrite.file_io import readPickle
appdirs = AppDirs("MarkWrite")
usersettings = readPickle(appdirs.user_config_dir,u'usersettings.pkl')
app = QtGui.QApplication(sys.argv)
from markwrite.gui.projectsettings import ProjectSettingsDialog
_ = ProjectSettingsDialog(savedstate=usersettings)
from markwrite.gui.projectsettings import SETTINGS
pg.setConfigOption('background', SETTINGS['plotviews_background_color'])
pg.setConfigOption('foreground', SETTINGS['plotviews_foreground_color'])
wmwin = MarkWriteMainWindow(app)
MarkWriteMainWindow._appdirs = appdirs
wmwin.show()
status = app.exec_()
sys.exit(status)
def handleUpdatedSettingsEvent(self, updates, settings):
penarray, brusharray = None, None
penpoints = self.getCurrentPenData()
for k in updates.keys():
if k.startswith('timeplot_xtrace'):
penarray, brusharray = self.updateTrace('xy_plot', 'x', 'timeplot_xtrace_color', 'timeplot_xtrace_size', penpoints, penarray, brusharray)
break
for k in updates.keys():
if k.startswith('timeplot_ytrace'):
self.updateTrace('xy_plot', 'y', 'timeplot_ytrace_color', 'timeplot_ytrace_size', penpoints, penarray, brusharray)
break
prev_bottom_plot = self.bottom_plot
if 'display_timeplot_atrace' in updates.keys():
plot_currently_displayed = hasattr(self,'acceleration_plot') and self.acceleration_plot is not None
if plot_currently_displayed and updates['display_timeplot_atrace'] is False:
self.removeAccelerationPlot()
elif not plot_currently_displayed and updates['display_timeplot_atrace'] is True:
self.createAccelerationPlot(SETTINGS['timeplot_enable_ymouse'])
penarray, brusharray = self.updateTrace('acceleration_plot', 'xy_acceleration', 'timeplot_atrace_color', 'timeplot_atrace_size', penpoints, penarray, brusharray)
else:
if hasattr(self,'acceleration_plot'):
for k in updates.keys():
if k.startswith('timeplot_atrace'):
penarray, brusharray = self.updateTrace('acceleration_plot', 'xy_acceleration', 'timeplot_atrace_color', 'timeplot_atrace_size', penpoints, penarray, brusharray)
break
if 'display_timeplot_xtrace' in updates.keys():
self.plotitems['xy_plot']['x'].setVisible(SETTINGS['display_timeplot_xtrace'])
if 'display_timeplot_ytrace' in updates.keys():
self.plotitems['xy_plot']['y'].setVisible(SETTINGS['display_timeplot_ytrace'])
if 'display_timeplot_vtrace' in updates.keys():
plot_currently_displayed = hasattr(self,'velocity_plot') and self.velocity_plot is not None
if plot_currently_displayed and updates['display_timeplot_vtrace'] is False:
self.removeVelocityPlot()
elif not plot_currently_displayed and updates['display_timeplot_vtrace'] is True:
self.createVelocityPlot(SETTINGS['timeplot_enable_ymouse'])
penarray, brusharray = self.updateTrace('velocity_plot', 'xy_velocity', 'timeplot_vtrace_color', 'timeplot_vtrace_size', penpoints, penarray, brusharray)
else:
if hasattr(self,'velocity_plot'):
for k in updates.keys():
if k.startswith('timeplot_vtrace'):
penarray, brusharray = self.updateTrace('velocity_plot', 'xy_velocity', 'timeplot_vtrace_color', 'timeplot_vtrace_size', penpoints, penarray, brusharray)
break
if self.bottom_plot != prev_bottom_plot:
prev_bottom_plot.hideAxis('bottom')
self.bottom_plot.setLabel('bottom', text="Time", units='sec')
for k in updates.keys():
if k.startswith('pen_stroke_boundary') or k.startswith('display_timeplot_xtrace') or k.startswith('display_timeplot_ytrace'):
proj = MarkWriteMainWindow.instance().project
pstart, pend = penpoints['time'][[0,-1]]
vms_times = proj.stroke_boundary_samples['time']
vms_mask = (vms_times >= pstart) & (vms_times <= pend)
self.addStrokeBoundaryPoints(proj.stroke_boundary_samples[vms_mask])
break
self.xy_plot.getViewBox().setMouseEnabled(y=SETTINGS['timeplot_enable_ymouse'])
if SETTINGS['timeplot_enable_ymouse'] is False:
self.xy_plot.setRange(yRange=self.fullPenValRange)
