def set2ndFlowGui(self):
#Create Ocean object: Operation and communication in parallel flow control
self.SensorOcean_func(self.oceanPVname)
#Instance: Determination of pressure data with data of graph'''
self.graphdata = DataCalculate()
# connect signals of SensorOcean -> PV of OceanOptics
self.SensorOcean.signal.connect(self.searchPressure)
#self.SensorOcean.finished.connect(self.finish)
self.SensorOcean.error_message.connect(self.errorMessage)
#Connect the most important signal (Acquire spectrogram)
self.ui.btnAcquire.released.connect(
self.managerUserInterfaceforacquisition_start)
self.ui.btnAcquireStop.released.connect(
self.managerUserInterfaceforacquisition_stop)
#It does not break the program
self.line = InfiniteLine()
self.line_calc = InfiniteLine()
self.ui.lcdPressure.setSmallDecimalPoint(True)
self.ui.lcdPressure.setDigitCount(6)
self.plotFlagDesired = None
self.dPressure = None
def add_crosshair(plot, render_measurements, color=Qt.gray):
pen = mkPen(color=QColor(color), width=1)
vline = InfiniteLine(angle=90, movable=False, pen=pen)
hline = InfiniteLine(angle=0, movable=False, pen=pen)
plot.addItem(vline, ignoreBounds=True)
plot.addItem(hline, ignoreBounds=True)
current_coordinates = None
reference_coordinates = None
def do_render():
render_measurements(current_coordinates, reference_coordinates)
def update(pos):
nonlocal current_coordinates
if plot.sceneBoundingRect().contains(pos):
mouse_point = plot.getViewBox().mapSceneToView(pos)
current_coordinates = mouse_point.x(), mouse_point.y()
vline.setPos(mouse_point.x())
hline.setPos(mouse_point.y())
do_render()
def set_reference(ev):
nonlocal reference_coordinates
if ev.button() == Qt.LeftButton and current_coordinates is not None:
reference_coordinates = current_coordinates
do_render()
plot.scene().sigMouseMoved.connect(update)
plot.scene().sigMouseClicked.connect(set_reference)
def plotAutomaticLineOnGraph(self, plot=True, w_l=694.26, _label='PV'):
''' Plotting line on graph '''
try:
if (plot):
if self.ui.chkDark.isChecked():
self.ui.wvRaw.plotItem.removeItem(self.line)
self.ui.wvDark.plotItem.removeItem(self.line)
self.line = InfiniteLine(pos=w_l,
angle=90,
pen=mkPen('r', width=2),
label=_label)
self.ui.wvDark.plotItem.addItem(self.line)
else:
self.ui.wvRaw.plotItem.removeItem(self.line)
self.ui.wvDark.plotItem.removeItem(self.line)
self.line = InfiniteLine(pos=w_l,
angle=90,
pen=mkPen('r', width=2),
label=_label)
self.ui.wvRaw.plotItem.addItem(self.line)
else:
self.ui.wvRaw.plotItem.removeItem(self.line)
self.ui.wvDark.plotItem.removeItem(self.line)
except:
self.showDialog("Error on pressure data processing",
"Mode Automatic: Error on pressure data plotting")
def __init__(self, diff, parent=None):
super(SideView, self).__init__(parent=parent)
self.parent = parent
self.brain = parent.brain
self.diff = diff
self.view1 = ViewBox()
self.setCentralItem(self.view1)
# Making Images out of data
self.brain.section = (self.brain.section + self.diff) % 3
self.i = int(self.brain.shape[self.brain.section] / 2)
data_slice = self.brain.get_data_slice(self.i)
self.brain_img1 = ImageItem(
data_slice,
autoDownsample=False,
compositionMode=QtGui.QPainter.CompositionMode_SourceOver)
self.brain.section = (self.brain.section - self.diff) % 3
self.view1.addItem(self.brain_img1)
self.view1.setAspectLocked(True)
self.view1.setFixedHeight(250)
self.view1.setFixedWidth(250)
self.setMinimumHeight(250)
self.vLine = InfiniteLine(angle=90, movable=False)
self.hLine = InfiniteLine(angle=0, movable=False)
self.vLine.setVisible(False)
self.hLine.setVisible(False)
self.view1.addItem(self.vLine, ignoreBounds=True)
self.view1.addItem(self.hLine, ignoreBounds=True)
def draw_average_line(self):
"""
method for drawing average lines on plot widget
"""
pen_1 = mkPen(color="#4c96d7", style=Qt.DotLine, width=2)
average_line_1 = InfiniteLine(angle=90, movable=False, pen=pen_1)
average_line_2 = InfiniteLine(angle=90, movable=False, pen=pen_1)
pen_2 = mkPen(color="#4c96d7", style=Qt.SolidLine, width=2)
average_line_3 = InfiniteLine(angle=90, movable=False, pen=pen_2)
average_line_4 = InfiniteLine(angle=90, movable=False, pen=pen_2)
brush = QBrush(QColor(0, 0, 255, 20))
if sum(self.y_1) != 0:
average_1 = np.average(self.x_1, weights=self.y_1)
linear_region_1 = LinearRegionItem([average_1, self.average], movable=False,
brush=brush)
self.graphics_view_1.addItem(linear_region_1)
average_line_1.setPos(average_1)
self.graphics_view_1.addItem(average_line_1)
if sum(self.y_2) != 0:
average_2 = np.average(self.x_2, weights=self.y_2)
linear_region_2 = LinearRegionItem([average_2, self.average], movable=False,
brush=brush)
self.graphics_view_2.addItem(linear_region_2)
average_line_2.setPos(average_2)
self.graphics_view_2.addItem(average_line_2)
average_line_3.setPos(self.average)
average_line_4.setPos(self.average)
self.graphics_view_1.addItem(average_line_3)
self.graphics_view_2.addItem(average_line_4)
def plotLine_nm_OnGraph(self,
plot=True,
w_l=694.26,
_label='PV',
_angle=90):
try:
if (plot):
if ((w_l > 600) and (w_l < 800)):
if self.ui.chkDark.isChecked():
self.ui.wvRaw.plotItem.removeItem(self.line_calc)
self.ui.wvDark.plotItem.removeItem(self.line_calc)
self.line_calc = InfiniteLine(pos=w_l,
angle=_angle,
pen=mkPen('g', width=2),
label=_label)
self.ui.wvDark.plotItem.addItem(self.line_calc)
else:
self.ui.wvRaw.plotItem.removeItem(self.line_calc)
self.ui.wvDark.plotItem.removeItem(self.line_calc)
self.line_calc = InfiniteLine(pos=w_l,
angle=_angle,
pen=mkPen('g', width=2),
label=_label)
self.ui.wvRaw.plotItem.addItem(self.line_calc)
else:
self.showDialog("Error plotting procedure",
"Wavelength is out of range")
else:
self.ui.wvRaw.plotItem.removeItem(self.line_calc)
self.ui.wvDark.plotItem.removeItem(self.line_calc)
except:
self.showDialog("Error on pressure data processing",
"Mode Automatic: Error on pressure data plotting")
def enableCrosshair(self,
is_enabled,
starting_x_pos,
starting_y_pos,
vertical_angle=90,
horizontal_angle=0,
vertical_movable=False,
horizontal_movable=False):
"""
Enable the crosshair to be drawn on the ViewBox.
Parameters
----------
is_enabled : bool
True is to draw the crosshair, False is to not draw.
starting_x_pos : float
The x coordinate where to start the vertical crosshair line.
starting_y_pos : float
The y coordinate where to start the horizontal crosshair line.
vertical_angle : float
The angle to tilt the vertical crosshair line. Default at 90 degrees.
horizontal_angle
The angle to tilt the horizontal crosshair line. Default at 0 degrees.
vertical_movable : bool
True if the vertical line can be moved by the user; False is not.
horizontal_movable
False if the horizontal line can be moved by the user; False is not.
"""
if is_enabled:
self.vertical_crosshair_line = InfiniteLine(
pos=starting_x_pos,
angle=vertical_angle,
movable=vertical_movable)
self.horizontal_crosshair_line = InfiniteLine(
pos=starting_y_pos,
angle=horizontal_angle,
movable=horizontal_movable)
self.plotItem.addItem(self.vertical_crosshair_line)
self.plotItem.addItem(self.horizontal_crosshair_line)
self.crosshair_movement_proxy = SignalProxy(
self.plotItem.scene().sigMouseMoved,
rateLimit=60,
slot=self.mouseMoved)
else:
if self.vertical_crosshair_line:
self.plotItem.removeItem(self.vertical_crosshair_line)
if self.horizontal_crosshair_line:
self.plotItem.removeItem(self.horizontal_crosshair_line)
if self.crosshair_movement_proxy:
# self.crosshair_movement_proxy.disconnect()
proxy = self.crosshair_movement_proxy
proxy.block = True
try:
proxy.signal.disconnect(proxy.signalReceived)
proxy.sigDelayed.disconnect(proxy.slot)
except:
pass
def uigetgraph(self, pln, size):
"""."""
graph = Graph(self)
graph.doubleclick.connect(_part(self._set_enable_list, pln))
graph.plotItem.scene().sigMouseMoved.connect(
_part(self._show_tooltip, pln=pln))
if self.is_orb:
xlabel = 'BPM '
elif pln.lower().endswith('x'):
xlabel = 'CH '
else:
xlabel = 'CV '
xlabel += 'Position'
graph.setLabel('bottom', text=xlabel, units='m')
lab = 'Orbit' if self.is_orb else 'Kick Angle'
unit = 'm' if self.is_orb else 'rad'
graph.setLabel('left', text=lab, units=unit)
graph.setObjectName(lab.replace(' ', '') + pln)
for i, lname in enumerate(self.line_names):
opts = dict(y_channel='A',
x_channel='B',
name=lname,
color=self._get_color(pln, i),
redraw_mode=2,
lineStyle=1,
lineWidth=2 if i else 3,
symbol='o',
symbolSize=10)
graph.addChannel(**opts)
pen = mkPen(opts['color'], width=opts['lineWidth'])
pen.setStyle(4)
cpstd = InfiniteLine(pos=0.0, pen=pen, angle=0)
self.updater[i].ave_pstd[pln].connect(cpstd.setValue)
graph.addItem(cpstd)
cmstd = InfiniteLine(pos=0.0, pen=pen, angle=0)
self.updater[i].ave_mstd[pln].connect(cmstd.setValue)
graph.addItem(cmstd)
pen.setStyle(2)
cave = InfiniteLine(pos=0.0, pen=pen, angle=0)
self.updater[i].ave[pln].connect(cave.setValue)
graph.addItem(cave)
cdta = graph.curveAtIndex(-1)
self.updater[i].data_sig[pln].connect(
_part(self._update_waveform, cdta, pln, i))
cdta.setVisible(not i)
cdta.curve.setZValue(-4 * i)
cdta.scatter.setZValue(-4 * i)
for j, cur in enumerate((cpstd, cmstd, cave), 1):
cur.setZValue(-4 * i - j)
cur.setVisible(False)
graph.plotItem.legend.removeItem('')
graph.setStyleSheet("""
#{0}{{
min-width:{1}em;
min-height:{2}em;
}}""".format(lab.replace(' ', '') + pln, size[0], size[1]))
return graph
def __init__(self, parent, style="dark"):
self._ySeries = None
self.plotItem = None
self.style = PlotStyle(style)
self.setStyle(style)
self.dateAxis = CustomDateAxisItem()
self.plotItem = CustomPlotItem(viewBox=CustomViewBox(),
axisItems={
'bottom': self.dateAxis,
'left': CustomAxisItem('left')
})
super().__init__(plotItem=self.plotItem)
self.dateAxis.axisDoubleClicked.connect(self.setPlotRange)
self.hgltPnt = None
self.parent = parent
self.plottable = ['speed', 'distance', 'time', 'calories']
self._initRightAxis()
# axis labels
self.plotItem.setLabel('bottom', text='Date')
# show grid on left and bottom axes
self.plotItem.getAxis('left').setGrid(255)
self.plotItem.getAxis('bottom').setGrid(255)
# cross hairs
self.vLine = InfiniteLine(angle=90, movable=False)
self.hLine = InfiniteLine(angle=0, movable=False)
self.plotItem.addItem(self.vLine, ignoreBounds=True)
self.plotItem.addItem(self.hLine, ignoreBounds=True)
self.plotItem.scene().sigMouseMoved.connect(self.mouseMoved)
self.plotItem.scene().sigMouseClicked.connect(self.plotClicked)
# update second view box
self.updateViews()
self.plotItem.vb.sigResized.connect(self.updateViews)
self.currentPoint = {}
# all points that are/were PBs can be highlighted
self._showPBs = False
self._regenerateCachedPBs = {key: False for key in self.plottable}
self.hgltPBs = {key: [] for key in self.plottable}
self.viewMonths = None
self.setYSeries('speed')
self.plotTotalDistance()
def __init__(self, parent):
super().__init__(parent)
self.parent = parent
self.projection, self.projection_vb, self.projection_hist = self.image_in_vb(
"Projection")
self.sinogram, self.sinogram_vb, self.sinogram_hist = self.image_in_vb(
"Sinogram")
self.recon, self.recon_vb, self.recon_hist = self.image_in_vb("Recon")
self.slice_line = InfiniteLine(pos=1024,
angle=0,
bounds=[0, self.projection.width()],
movable=True)
self.projection_vb.addItem(self.slice_line)
self.tilt_line = InfiniteLine(pos=1024,
angle=90,
pen=(255, 0, 0, 255),
movable=True)
image_layout = self.addLayout(colspan=4)
image_layout.addItem(self.projection_vb, 0, 0)
image_layout.addItem(self.projection_hist, 0, 1)
image_layout.addItem(self.recon_vb, 0, 2, rowspan=3)
image_layout.addItem(self.recon_hist, 0, 3, rowspan=3)
projection_details = LabelItem("Value")
image_layout.addItem(projection_details, 1, 0, 1, 2)
image_layout.addItem(self.sinogram_vb, 2, 0)
image_layout.addItem(self.sinogram_hist, 2, 1)
sino_details = LabelItem("Value")
image_layout.addItem(sino_details, 3, 0, 1, 2)
recon_details = LabelItem("Value")
image_layout.addItem(recon_details, 3, 2, 1, 2)
msg_format = "Value: {:.6f}"
self.display_formatted_detail = {
self.projection:
lambda val: projection_details.setText(msg_format.format(val)),
self.sinogram:
lambda val: sino_details.setText(msg_format.format(val)),
self.recon:
lambda val: recon_details.setText(msg_format.format(val))
}
self.projection.hoverEvent = lambda ev: self.mouse_over(
ev, self.projection)
self.projection.mouseClickEvent = lambda ev: self.mouse_click(
ev, self.slice_line)
self.slice_line.sigPositionChangeFinished.connect(
self.slice_line_moved)
self.sinogram.hoverEvent = lambda ev: self.mouse_over(
ev, self.sinogram)
self.recon.hoverEvent = lambda ev: self.mouse_over(ev, self.recon)
def __init__(self, *args, **kwargs):
super(Crosshair, self).__init__(*args, **kwargs)
linepen = mkPen("#FFA500")
self._vline = InfiniteLine((0, 0), angle=90, movable=False, pen=linepen)
self._hline = InfiniteLine((0, 0), angle=0, movable=False, pen=linepen)
self._vline.setVisible(False)
self._hline.setVisible(False)
self.addItem(self._vline)
self.addItem(self._hline)
self.scene.sigMouseMoved.connect(self.moveCrosshair)
def __init__(self, parent):
super().__init__(parent)
self.parent = parent
self.projection, self.projection_vb, self.projection_hist = self.image_in_vb("Projection")
self.sinogram, self.sinogram_vb, self.sinogram_hist = self.image_in_vb("Sinogram")
self.recon, self.recon_vb, self.recon_hist = self.image_in_vb("Recon")
self.slice_line = InfiniteLine(pos=1024, angle=0, bounds=[0, self.projection.width()], movable=True)
self.projection_vb.addItem(self.slice_line)
self.tilt_line = InfiniteLine(pos=1024, angle=90, pen=(255, 0, 0, 255), movable=True)
image_layout = self.addLayout(colspan=4)
image_layout.addItem(self.projection_vb, 0, 0)
image_layout.addItem(self.projection_hist, 0, 1)
image_layout.addItem(self.recon_vb, 0, 2, rowspan=3)
image_layout.addItem(self.recon_hist, 0, 3, rowspan=3)
projection_details = LabelItem("Value")
image_layout.addItem(projection_details, 1, 0, 1, 2)
image_layout.addItem(self.sinogram_vb, 2, 0)
image_layout.addItem(self.sinogram_hist, 2, 1)
sino_details = LabelItem("Value")
image_layout.addItem(sino_details, 3, 0, 1, 2)
recon_details = LabelItem("Value")
image_layout.addItem(recon_details, 3, 2, 1, 2)
msg_format = "Value: {:.6f}"
self.display_formatted_detail = {
self.projection: lambda val: projection_details.setText(msg_format.format(val)),
self.sinogram: lambda val: sino_details.setText(msg_format.format(val)),
self.recon: lambda val: recon_details.setText(msg_format.format(val))
}
self.projection.hoverEvent = lambda ev: self.mouse_over(ev, self.projection)
self.projection.mouseClickEvent = lambda ev: self.mouse_click(ev, self.slice_line)
self.slice_line.sigPositionChangeFinished.connect(self.slice_line_moved)
self.sinogram.hoverEvent = lambda ev: self.mouse_over(ev, self.sinogram)
self.recon.hoverEvent = lambda ev: self.mouse_over(ev, self.recon)
# Work around for https://github.com/mantidproject/mantidimaging/issues/565
for scene in [
self.projection.scene(),
self.projection_hist.scene(),
self.sinogram.scene(),
self.sinogram_hist.scene(),
self.recon.scene(),
self.recon_hist.scene(),
]:
scene.contextMenu = [item for item in scene.contextMenu if "export" not in item.text().lower()]
def _plot_cutpoint(self, x):
"""
Function plots the cutpoint.
Parameters
----------
x : int
Cutpoint location.
"""
if x is None:
self._line = None
return
if self._line is None:
# plot interactive vertical line
self._line = InfiniteLine(angle=90,
pos=x,
movable=True,
bounds=self.selection_limit
if self.selection_limit is not None else
(self.x.min(), self.x.max()))
self._line.setCursor(Qt.SizeHorCursor)
self._line.setPen(mkPen(QColor(Qt.black), width=2))
self._line.sigPositionChanged.connect(self._on_cut_changed)
self.addItem(self._line)
else:
self._line.setValue(x)
self._update_horizontal_lines()
def __init__(self, linePos=650, txtPosRatio=0.35, invertX=True, *args, **kwargs):
"""
A widget to display a 1D spectrum
:param linePos: the initial position of the InfiniteLine
:param txtPosRatio: a coefficient that determines the relative position of the textItem
:param invertX: whether to invert X-axis
"""
super(SpectraPlotWidget, self).__init__(*args, **kwargs)
self._data = None
assert (txtPosRatio >= 0) and (txtPosRatio <= 1), 'Please set txtPosRatio value between 0 and 1.'
self.txtPosRatio = txtPosRatio
self.positionmap = dict()
self.wavenumbers = None
self._meanSpec = True # whether current spectrum is a mean spectrum
self.line = InfiniteLine(movable=True)
self.line.setPen((255, 255, 0, 200))
self.line.setValue(linePos)
self.line.sigPositionChanged.connect(self.sigEnergyChanged)
self.line.sigPositionChanged.connect(self.getEnergy)
self.addItem(self.line)
self.cross = PlotDataItem([linePos], [0], symbolBrush=(255, 0, 0), symbolPen=(255, 0, 0), symbol='+',
symbolSize=20)
self.cross.setZValue(100)
self.addItem(self.cross)
self.txt = TextItem()
self.getViewBox().invertX(invertX)
self.spectrumInd = 0
self.selectedPixels = None
self._y = None
def __init__(self, parent):
super().__init__(parent)
self.parent = parent
self.imageview_projection = MIMiniImageView(name="Projection")
self.imageview_sinogram = MIMiniImageView(name="Sinogram")
self.imageview_recon = MIMiniImageView(name="Recon")
self.projection, self.projection_vb, self.projection_hist = self.imageview_projection.get_parts(
)
self.sinogram, self.sinogram_vb, self.sinogram_hist = self.imageview_sinogram.get_parts(
)
self.recon, self.recon_vb, self.recon_hist = self.imageview_recon.get_parts(
)
self.slice_line = InfiniteLine(
pos=1024,
angle=0,
bounds=[0, self.imageview_projection.image_item.width()],
movable=True)
self.projection_vb.addItem(self.slice_line)
self.tilt_line = InfiniteLine(pos=1024,
angle=90,
pen=(255, 0, 0, 255),
movable=True)
self.addItem(self.imageview_projection, 0, 0)
self.addItem(self.imageview_recon, 0, 1, rowspan=2)
self.addItem(self.imageview_sinogram, 1, 0)
self.imageview_projection.image_item.mouseClickEvent = lambda ev: self.mouse_click(
ev, self.slice_line)
self.slice_line.sigPositionChangeFinished.connect(
self.slice_line_moved)
# Work around for https://github.com/mantidproject/mantidimaging/issues/565
self.scene().contextMenu = [
item for item in self.scene().contextMenu
if "export" not in item.text().lower()
]
self.imageview_projection.enable_nan_check()
self.imageview_sinogram.enable_nan_check()
self.imageview_recon.enable_nan_check()
self.imageview_projection.enable_nonpositive_check()
self.imageview_sinogram.enable_nonpositive_check()
def offsetDepthOnPlot(self, side):
self.sideToOffset = side
self.rightShelfBtn.deleteLater()
self.leftShelfBtn.deleteLater()
self.btnLay.deleteLater()
self.btnLay, self.leftShelfBtn, self.rightShelfBtn = None, None, None
self.offsetDepthLine = InfiniteLine(pen=mkPen(width=1.5, color='y'))
self.btn3.setVisible(True)
self.plotWidget.scene().sigMouseClicked.connect(self.firstClickOnPlot)
def __init__(self, parent=None):
super().__init__(parent)
self.plot_item = self.addPlot()
self.plot_item.setMenuEnabled(False)
self.inf_line = InfiniteLine(0,
pen=get_pen(color='red',
style=Qt.DashLine))
self.plot_item.addItem(self.inf_line)
self.plots = {}
self.x_axis: Dict[int, List[int]] = {}
def __init__(self, *args, **kwargs):
kwargs['viewBox'] = ScanViewBox() # Use custom pg.ViewBox subclass
super().__init__(*args, **kwargs)
self.getViewBox().sigMouseAreaSelected.connect(
self.sigMouseAreaSelected)
self._min_crosshair_factor = 0.02
self._crosshair_size = (0, 0)
self._crosshair_range = None
self.getViewBox().sigRangeChanged.connect(
self._constraint_crosshair_size)
self.crosshair = ROI((0, 0), (0, 0),
pen={
'color': '#00ff00',
'width': 1
})
self.hline = InfiniteLine(pos=0,
angle=0,
movable=True,
pen={
'color': '#00ff00',
'width': 1
},
hoverPen={
'color': '#ffff00',
'width': 1
})
self.vline = InfiniteLine(pos=0,
angle=90,
movable=True,
pen={
'color': '#00ff00',
'width': 1
},
hoverPen={
'color': '#ffff00',
'width': 1
})
self.vline.sigDragged.connect(self._update_pos_from_line)
self.hline.sigDragged.connect(self._update_pos_from_line)
self.crosshair.sigRegionChanged.connect(self._update_pos_from_roi)
self.sigCrosshairDraggedPosChanged.connect(self.sigCrosshairPosChanged)
def prepare_plot(self) -> None:
"""
Method to prepare the plot
:return: None
"""
# If the data array is empty, return
if not self.data:
return
# Calculate the average
av = np.average(self.data)
# Get the unique elements of data and their counts
unique, counts = np.unique(self.data, return_counts=True)
# Calculate the occurence probability of all unique elements
prob = [counts[x] / np.sum(counts) for x in range(len(counts))]
# Calculate the probability of elements to occur according to the poisson distrubution
poisson = self.poisson(av, np.arange(0, max(unique)))
# Prepare bar graphs
self.data_graph = pg.BarGraphItem(x=unique - 0.1,
height=prob,
width=0.2,
brush=pg.mkBrush(color=(255, 50, 30,
255)))
self.data_graph_line = pg.PlotDataItem(unique - 0.1,
prob,
pen=pg.mkPen(color=(255, 50, 30,
100),
width=5))
self.poisson_graph = pg.BarGraphItem(x=np.arange(0, max(unique)) + 0.1,
height=poisson,
width=0.2,
brush=pg.mkBrush(color=(85, 30,
255,
255)))
self.poisson_graph_line = pg.PlotDataItem(
np.arange(0, max(unique)) + 0.1,
poisson,
pen=pg.mkPen(color=(85, 30, 255, 100), width=5))
self.data_average_line = InfiniteLine(av,
angle=90,
pen=pg.mkPen(color=(0, 255, 0,
255)))
# Add indicator for data average
self.addItem(self.data_average_line)
# self.addItem(self.data_graph_line)
# self.addItem(self.poisson_graph_line)
self.addItem(self.poisson_graph)
self.addItem(self.data_graph)
self.setToolTip(
"Red: Data Distribution\nBlue: Poisson Distribution\nGreen: Average"
)
# Add Legend
# TODO
"""
def View_TOCSY_Data(self):
try:
self.plot.clear()
ID = self.NMR_Data_View_Selector.currentText()
TOCSY_DATA = pd.read_json(os.path.join(MasterOutput,ID,str(ID+"_TOCSY_Data.json")))
self.plot.plot(TOCSY_DATA.Ha,TOCSY_DATA.Hb,pen=None,symbol="o" )
self.plot.invertX(True)
self.plot.invertY(True)
vLine = InfiniteLine(angle=45, movable=False)
self.plot.addItem(vLine)
except:
PopUP('Data not found','Selected Dataset not found. Please process in Topspin Prior to running MADByTE. For 2D Datasets, the displayed data is derived from peak picking lists.','Error')
def on_pushButton_3_clicked(self):
"""
Slot documentation goes here.
"""
# answers = []
# for answer in db['question_'+str(self.index)].find():
# text = answer['content'].replace('\n', '')
# if 5 < len(text) < 100:
# answers.append(text)
answers = [
answer['content'].replace('\n', '')
for answer in db['question_' + str(self.index)].find()
]
Line1 = InfiniteLine(pos=0, pen=(255, 0, 0), angle=0, movable=False)
Line2 = InfiniteLine(pos=0.5, pen=(0, 0, 255), angle=0, movable=False)
Line3 = InfiniteLine(pos=1, pen=(0, 255, 0), angle=0, movable=False)
import sys
start = perf_counter()
data = LSTM.get_result(answers,
vec_path=sys.path[0] + '/lstm/vec_lstm.pkl',
model_path=sys.path[0] + '/lstm/lstmModel.pkl')
end = perf_counter()
print('情感分析总用时：' + str(end - start) + 's')
tricks = [(0, '消极'), (0.5, '中立'), (1, '积极')]
strAxis = AxisItem(orientation='left', maxTickLength=3)
strAxis.setTicks([
tricks,
])
visitor_count_plot = PlotWidget(axisItems={'left': strAxis},
background=None)
visitor_count_plot.plot(y=data, pen=None, symbol='o')
visitor_count_plot.showAxis('bottom', False)
visitor_count_plot.addItem(Line1)
visitor_count_plot.addItem(Line2)
visitor_count_plot.addItem(Line3)
visitor_count_plot.setObjectName("tab")
# visitor_count_plot.enableAutoRange('x', x_axis_scale)
self._add_analysis_tab(visitor_count_plot, '情感分析')
self.pushButton_3.setEnabled(False)
def __init__(self, plots):
"""
Constructor
arguments:
- plots: the plots
returns: the initialized class
"""
self.plots = plots
self.cursor_x = [None] * 3
self.cursor_y = [None] * 3
self.cursor_label = [None] * 3
self.signal_proxy = [None] * 3
self.plot_data_items = [None] * 3
self._x = [None] * 3
self._y = [None] * 3
for num, plot in enumerate(plots):
self.cursor_x[num] = InfiniteLine(angle=90, movable=False)
self.cursor_y[num] = InfiniteLine(angle=0, movable=False)
plot.addItem(self.cursor_x[num], ignoreBounds=True)
plot.addItem(self.cursor_y[num], ignoreBounds=True)
self.signal_proxy[num] = SignalProxy(plot.scene().sigMouseMoved,
rateLimit=60,
slot=self.update_cursor)
self.cursor_label[num] = TextItem('', (255, 255, 255),
anchor=(0, 0))
self.cursor_label[num].setPos(-10.4, 10)
plot.addItem(self.cursor_label[num])
# Find the PlotDataItem displaying data
for item in plot.getPlotItem().items:
if isinstance(item, PlotDataItem):
self.plot_data_items[num] = item
self.hide_cursors()
def initializeBinds(self):
# añadir plots
self.pushButtonPlay.clicked.connect(self.play)
self.pushButton.clicked.connect(self.showFFT)
setConfigOption('leftButtonPan', False)
self.x = 0
self.y = 0
self.zoomedPlot = self.graphicsView.addPlot(row=1, col=0)
self.fullPlot = self.graphicsView.addPlot(row=2, col=0)
self.graphicsView.setBackground(background="w")
# self.zoomedPlot.vb.setBackgroundColor("w")
# self.fullPlot.vb.setBackgroundColor("w")
self.penB = mkPen('b')
self.penR = mkPen('r')
self.region = LinearRegionItem()
self.region.setZValue(10)
self.vb = self.zoomedPlot.vb
self.region.setRegion([1000, 2000])
self.fullPlot.addItem(self.region, ignoreBounds=True)
# pg.dbg()
self.zoomedPlot.setAutoVisible(y=True)
self.vLine = InfiniteLine(angle=90, movable=False)
self.hLine = InfiniteLine(angle=0, movable=False)
self.zoomedPlot.addItem(self.vLine, ignoreBounds=True)
self.zoomedPlot.addItem(self.hLine, ignoreBounds=True)
# signal para capturar evento de raton
# proxy = SignalProxy(self.zoomedPlot.scene().sigMouseMoved, rateLimit=60, slot=self.mouseMoved)
self.zoomedPlot.scene().sigMouseMoved.connect(self.mouseMoved)
self.region.sigRegionChanged.connect(self.update)
self.zoomedPlot.sigRangeChanged.connect(self.updateRegion)
def create_infinite_line(gui: Interface, graphDict: dict, colors: list = None):
"""
Creates an infinite (hover) line and adds it as a reference to the graph dictionary provided.
:param gui: Graphical user interface in which to set up graphs.
:param colors: Optional colors list.
:param graphDict: A reference to this infinite line will be added to this graph dictionary.
"""
colors = get_graph_colors(gui=gui) if colors is None else colors
hover_line = InfiniteLine(pos=0,
pen=mkPen(colors[-1], width=1),
movable=False)
graphDict['graph'].addItem(hover_line)
graphDict['line'] = hover_line
def __init__(self, *args, **kwargs):
PlotWidget.__init__(self, *args, **kwargs)
self.fit_range_marker = InfiniteLine(movable=True,
pen=mkPen('w', width=2))
self.text_no_data = TextItem('Press "Analyze" to display results',
anchor=(0.5, 0.5))
self._log_mode = False
self.showGrid(x=True, y=True)
self.addItem(self.fit_range_marker)
self.addItem(self.text_no_data)
self.reset()
self.fit_range_marker.sigPositionChangeFinished.connect(
self.sigFitRangeChanged.emit)
def __init__(self, parent=None):
super().__init__(parent=parent)
self.ui.histogram.hide()
self.ui.roiBtn.hide()
self.ui.menuBtn.hide()
self.image_view_text = TextItem(text="",
color=(255, 0, 0),
anchor=(0, 0))
self.getView().addItem(self.image_view_text)
self.image_view_vline = InfiniteLine(angle=90, movable=False)
self.image_view_hline = InfiniteLine(angle=0, movable=False)
self.getView().addItem(self.image_view_vline, ignoreBounds=True)
self.getView().addItem(self.image_view_hline, ignoreBounds=True)
self.image_view_proxy = SignalProxy(
self.getView().scene().sigMouseMoved,
rateLimit=60,
slot=self.onMouseMoved)
self.signals = FilteratorImageViewSignals()
def __init__(self, x: list, y: list, graphics_view: PlotWidget, labels: str,
units=None, x_labels=None, width=0.4):
"""
Constructor / Instantiation of class
Parameters
----------
x : list
x-values
y : list
y-values
graphics_view : PlotWidget
widget to add items
labels : str
legend labels
units : tuple
measurement units for tuple
width : int, float
width of any bars
x_labels : array-like
array of dates, i.e. time-period
"""
super().__init__()
Assertor.assert_data_types([x, y, graphics_view, labels, units, x_labels, width],
[list, list, PlotWidget, str, (type(None), tuple),
(type(None), list), (float, int)])
self.x = asarray(arange(1, len(x) + 1, 1))
self.y = asarray([float(val.replace(" ", "").replace("%", "")) if val else 0 for val in y])
self.graphics_view = graphics_view
self.labels = labels
self.units = units if units else tuple(["" for _ in range(10)])
self.x_time = x_labels
self.width = width
self.bar_item_1 = BarGraphItem(x=self.x, height=self.y, width=self.width, brush="#a8ccec")
self.graphics_view.addItem(self.bar_item_1)
self.bar_item_2 = None
self.label = TextItem()
pen = mkPen(color="#4c96d7", style=Qt.SolidLine, width=1)
self.vertical_line = InfiniteLine(angle=90, movable=False, pen=pen)
self.graphics_view.addItem(self.vertical_line)
self.view_box = self.graphics_view.getViewBox()
self.configure_cross_hair()
self.graphics_view.plotItem.vb.setLimits(xMin=0, xMax=max(self.x) + 1)
self.graphics_view.setMenuEnabled(False)
def __init__(self, *args, **kwargs):
super(SpectraPlotWidget, self).__init__(*args, **kwargs)
self._data = None
self.positionmap = dict()
self.wavenumbers = None
self._meanSpec = True # whether current spectrum is a mean spectrum
self.line = InfiniteLine(movable=True)
self.line.setPen((255, 255, 0, 200))
self.line.setZValue(100)
self.line.sigPositionChanged.connect(self.sigEnergyChanged)
self.line.sigPositionChanged.connect(self.getEnergy)
self.addItem(self.line)
self.getViewBox().invertX(True)
self.selectedPixels = None
self._y = None
def __init__(self, slice_direction, xlink=None, ylink=None, parent=None):
super(PlotView, self).__init__(parent=parent)
self.slice_direction = slice_direction
self._curve = self.plot()
if slice_direction == 'horizontal':
angle = 0
elif slice_direction in ['vertical', 'depth']:
angle = 90
else:
raise NotImplementedError
self.crosshair = InfiniteLine(0,
angle=angle,
movable=True,
markers=[('^', 0), ('v', 1)])
self.crosshair.sigPositionChanged.connect(self.sigCrosshairMoved)
self.addItem(self.crosshair)
def __init__(self, *args, layout=None, include_line=False, **kwargs):
# Load specviz plugins
Application.load_local_plugins()
super(SpecvizDataViewer, self).__init__(*args, **kwargs)
self.statusBar().hide()
# Instantiate workspace widget
self.current_workspace = Workspace()
self.hub = Hub(self.current_workspace)
# Store a reference to the cubeviz layout instance
self._layout = layout
# Add an initially empty plot window
self.current_workspace.add_plot_window()
self.setCentralWidget(self.current_workspace)
self.options.gridLayout.addWidget(self.current_workspace.list_view)
# When a new data item is added to the specviz model, create a new
# glue data component and add it to the glue data list
# self.current_workspace.model.data_added.connect(self.reverse_add_data)
self.current_workspace.mdi_area.setViewMode(QMdiArea.SubWindowView)
self.current_workspace.current_plot_window.setWindowFlags(Qt.FramelessWindowHint)
self.current_workspace.current_plot_window.showMaximized()
# Create and attach a movable vertical line indicating the current
# slice position in the cube
if include_line:
self._slice_indicator = InfiniteLine(0, movable=True,
pen={'color': 'g', 'width': 3})
self.current_workspace.current_plot_window.plot_widget.addItem(
self._slice_indicator)
