def __init__(self, pos, vel, charge, eneg, idempot, dt):
pg.setConfigOptions(antialias=True)
self.app = QtGui.QApplication([])
self.w = pg.GraphicsWindow()
self.w.setWindowTitle('Particles')
self.g = pg.GraphItem()
self.v = self.w.addPlot()
self.v.addItem(self.g)
self.view_window = (-11, 11)
self.wall_dist = (-10, 10)
self.dragged_point_index = None
self.dragOffset = None
self.dt = dt
self.position = pos
self.vel = vel
self.charge = charge
self.eneg = eneg
self.idempot = idempot
self.n_part = len(pos)
self.eq_dist = 1
self.grav_pull = np.array([0, -1]) * 0.00000
self.max_vel = 1
self.cmap = pg.ColorMap([-0.5, 0, 0.5],
np.array([[255, 0, 0,
255], [255, 255, 255, 255],
[0, 0, 255, 255]]))
pg.GraphItem.__init__(self)
def __init__(self, parent=None):
self.play = True
self.frames = 50
self.xdim = 600
self.ydim = 600
self.noize = 1
self.data = None
self.text = custom_graph.CustomGraph()
self.item = pg.ImageItem()
self.i = None
self.mass_centers = pg.GraphItem()
self.fps = None
self.updateTime = None
#self.pos = np.linspace(0, 1, 256)
#n = len(self.pos)
#self.color = []
#for i in range(n):
# self.color.append([((n-i)/n), (i/n), ((n-i)/n), 1])
#self.colmap = pg.ColorMap(self.pos, self.color)
#self.lut = self.colmap.getLookupTable(0, 1.0, 256)
colormap = cm.get_cmap("plasma") # cm.get_cmap("CMRmap")
colormap._init()
self.lut = (colormap._lut * 255).view(np.ndarray)
super().__init__(parent)
self.initUI()
def display_grid(self):
# remove previous grid if any
if self.parent.grid_view['item']:
self.parent.ui.image_view.removeItem(self.parent.grid_view['item'])
# if we want a grid
if self.parent.ui.grid_display_checkBox.isChecked():
grid_size = self.parent.ui.grid_size_slider.value()
[width, height] = np.shape(self.parent.live_image)
pos_adj_dict = self.calculate_matrix_grid(grid_size=grid_size,
height=height,
width=width)
pos = pos_adj_dict['pos']
adj = pos_adj_dict['adj']
line_color = self.parent.grid_view['color']
_transparency_value = 255 - (np.float(str(self.parent.ui.transparency_slider.value()))/100) * 255
_list_line_color = list(line_color)
_list_line_color[3] = _transparency_value
line_color = tuple(_list_line_color)
lines = np.array([line_color for n in np.arange(len(pos))],
dtype=[('red', np.ubyte), ('green', np.ubyte),
('blue', np.ubyte), ('alpha', np.ubyte),
('width', float)])
grid = pg.GraphItem()
self.parent.ui.image_view.addItem(grid)
grid.setData(pos=pos,
adj=adj,
pen=lines,
symbol=None,
pxMode=False)
self.parent.grid_view['item'] = grid
def show(self):
if self._view is None:
pg.mkQApp()
self._view_widget = pg.GraphicsLayoutWidget()
self._view = self._view_widget.addViewBox(0, 0)
v = self._view
cell_ids = sorted(self.cells.keys())
pos = np.array([self.cells[i].position[:2] for i in cell_ids])
if len(self.connections) == 0:
adj = np.empty((0, 2), dtype='int')
else:
adj = np.array(self.connections) - 1
colors = []
for cid in cell_ids:
cell = self.cells[cid]
color = [0, 0, 0]
for i, cre in enumerate(self.cre_types):
if cell.labels[cre] == '+':
color[i] = 255
colors.append(color)
brushes = [pg.mkBrush(c) for c in colors]
print(pos)
print(adj)
print(colors)
self._graph = pg.GraphItem(pos=pos,
adj=adj,
size=30,
symbolBrush=brushes)
v.addItem(self._graph)
self._view_widget.show()
def __init__(self, color=None, tooltip=""):
"""
:param color: the color for the lines
:param tooltip: an optional tooltip to show
:return:
"""
SpectralVisualItemWrapper.__init__(self)
# time limits
self.indexFrom = 0
self.indexTo = 0
# the freq value
self.peak_freq_value = 0
if color is not None and isinstance(color, QtGui.QColor):
self.COLOR = color
# a line for peak freq
self.peak_freq_pos = np.array([[self.indexFrom, self.peak_freq_value],
[self.indexTo, self.peak_freq_value]])
self.peak_freq_region = pg.GraphItem()
self.tooltip = tooltip
self.peak_freq_region.setToolTip(self.tooltip)
def __init__(self, positions, parent=None):
super(Widget, self).__init__(parent=parent)
p = self.palette()
p.setColor(self.backgroundRole(), QtGui.QColor(100, 100, 100))
self.setPalette(p)
self.vertical_layout = QVBoxLayout(self)
self.win = pg.GraphicsWindow()
view_box = self.win.addViewBox()
self.graph_item = pg.GraphItem()
view_box.addItem(self.graph_item)
self.vertical_layout.addWidget(self.win)
self.eps_slider = Slider()
self.vertical_layout.addWidget(self.eps_slider)
self.v_rips_complex = VietorisRipsComplex(positions)
self.line_pen = pg.mkPen((238, 130, 238), width=3)
self.node_brushes = [pg.mkBrush('k') for _ in positions]
self.perim_nodes = [pg.mkBrush(color=(255, 165, 0, 40)) for _ in positions]
self.brushes = self.node_brushes + self.perim_nodes
self.node_sizes = [0.2 for _ in positions]
# Define the symbol to use for each node (this is optional)
self.symbols = ['o'] * len(self.v_rips_complex.network.nodes)
self.communicate = Communicate()
self.communicate.update_simplices.connect(self.update_simplices)
self.eps_slider.slider.valueChanged.connect(self.update_graph)
self.update_graph(0)
def display_roi(self):
if len(
np.array(self.parent.data_metadata['normalized']
['data_live_selection'])) == 0:
return
pos = self.parent.binning_line_view['pos']
adj = self.parent.binning_line_view['adj']
lines = self.parent.binning_line_view['pen']
if pos is None:
return
self.parent.fitting_ui.there_is_a_roi = True
# define new transparency of roi
transparency = self.parent.fitting_ui.slider.value()
lines = colors.set_alpha_value(lines=lines, transparency=transparency)
if self.parent.fitting_ui.line_view_fitting:
self.parent.fitting_ui.image_view.removeItem(
self.parent.fitting_ui.line_view_fitting)
line_view_fitting = pg.GraphItem()
self.parent.fitting_ui.line_view_fitting = line_view_fitting
self.parent.fitting_ui.image_view.addItem(line_view_fitting)
self.parent.fitting_ui.line_view = line_view_fitting
self.parent.fitting_ui.line_view.setData(pos=pos,
adj=adj,
pen=lines,
symbol=None,
pxMode=False)
def __init__(self, plot, parent, defaultSize, defaultGain, connectDots):
self.parent = parent
self.data = VisualizerData(defaultSize, defaultGain)
self.frame = 0
self.connectDots = connectDots
# Timings used for the output file
self.timings = {}
# Set the plot up for visualization
self.lines = pg.GraphItem(pos=np.array([(-100, -100)]))
plot.addItem(self.lines)
p = plot.getPlotItem()
p.setXRange(0, 10)
p.setYRange(0, 10)
p.showGrid(False, False)
p.showAxis('left', False)
p.showAxis('bottom', False)
p.setMouseEnabled(False, False)
p.hideButtons()
self.plotTimer = QtCore.QTimer()
self.plotTimer.setTimerType(QtCore.Qt.PreciseTimer)
self.plotTimer.timeout.connect(self.plotData)
self.audTimer = QtCore.QTimer()
self.audTimer.setTimerType(QtCore.Qt.PreciseTimer)
self.audTimer.timeout.connect(self.playAudio)
self.audComplete = QtCore.QTimer()
self.audComplete.timeout.connect(self.progressAudio)
def _define_profile(self):
# profile
# [x0, y0, width, height] = self.parent.get_item_row(row=self.row)
_profile_width = self.parent.get_profile_width(row=self.row)
is_x_profile_direction = self.parent.ui.profile_direction_x_axis.isChecked(
)
# delta_profile = (_profile_width - 1) / 2.
profile_dimension = self.parent.get_profile_dimensions(row=self.row)
x_left = profile_dimension.x_left
x_right = profile_dimension.x_right
y_top = profile_dimension.y_top
y_bottom = profile_dimension.y_bottom
if is_x_profile_direction:
pos = []
pos.append([x_left, y_top])
pos.append([x_right, y_top])
adj = []
adj.append([0, 1])
if y_top != y_bottom: # height == 1
pos.append([x_left, y_bottom])
pos.append([x_right, y_bottom])
adj.append([2, 3])
adj = np.array(adj)
pos = np.array(pos)
else: # y-profile direction
pos = []
pos.append([x_left, y_top])
pos.append([x_left, y_bottom])
adj = []
adj.append([0, 1])
if y_top != y_bottom: # height == 1
pos.append([x_right, y_top])
pos.append([x_right, y_bottom])
adj.append([2, 3])
adj = np.array(adj)
pos = np.array(pos)
line_color = self.parent.profile_color
_list_line_color = list(line_color)
line_color = tuple(_list_line_color)
lines = np.array([line_color for n in np.arange(len(pos))],
dtype=[('red', np.ubyte), ('green', np.ubyte),
('blue', np.ubyte), ('alpha', np.ubyte),
('width', float)])
profile = pg.GraphItem()
self.parent.ui.image_view.addItem(profile)
profile.setData(pos=pos, adj=adj, pen=lines, symbol=None, pxMode=False)
self.__profile = profile
def display_grid(self):
[width, height] = [self.width, self.height]
bin_size = self.grid_size
x0 = 0
y0 = 0
pos_adj_dict = {}
nbr_height_bins = np.float(height) / np.float(bin_size)
real_height = y0 + np.int(nbr_height_bins) * np.int(bin_size)
nbr_width_bins = np.float(width) / np.float(bin_size)
read_width = x0 + np.int(nbr_width_bins) * np.int(bin_size)
# pos (each matrix is one side of the lines)
pos = []
adj = []
# vertical lines
x = x0
index = 0
while (x <= x0 + width):
one_edge = [x, y0]
other_edge = [x, real_height]
pos.append(one_edge)
pos.append(other_edge)
adj.append([index, index + 1])
x += bin_size
index += 2
# horizontal lines
y = y0
while (y <= y0 + height):
one_edge = [x0, y]
other_edge = [read_width, y]
pos.append(one_edge)
pos.append(other_edge)
adj.append([index, index + 1])
y += bin_size
index += 2
pos = np.array(pos)
adj = np.array(adj)
line_color = (255, 0, 0, 155, 0.2)
lines = np.array([line_color for n in np.arange(len(pos))],
dtype=[('red', np.ubyte), ('green', np.ubyte),
('blue', np.ubyte), ('alpha', np.ubyte),
('width', float)])
line_view_binning = pg.GraphItem()
self.ui.image_view.addItem(line_view_binning)
line_view_binning.setData(pos=pos,
adj=adj,
pen=lines,
symbol=None,
pxMode=False)
self.line_view_binning = line_view_binning
def makeGraph(self):
#g1 = pg.GraphItem(pos=self.pos, adj=self.links[self.rope], pen=0.2, symbol=None)
brushes = np.where(self.fixed, pg.mkBrush(0,0,0,255), pg.mkBrush(50,50,200,255))
g2 = pg.GraphItem(pos=self.pos, adj=self.links[self.push & self.pull], pen=0.5, brush=brushes, symbol='o', size=(self.mass**0.33), pxMode=False)
p = pg.ItemGroup()
#p.addItem(g1)
p.addItem(g2)
return p
def _qtg_plot_graph(G, edges, vertex_size, title):
# TODO handling when G is a list of graphs
qtg, gl, QtGui = _import_qtg()
if G.is_directed():
raise NotImplementedError
else:
if G.coords.shape[1] == 2:
window = qtg.GraphicsWindow()
window.setWindowTitle(title)
view = window.addViewBox()
view.setAspectLocked()
if edges:
pen = tuple(np.array(G.plotting['edge_color']) * 255)
else:
pen = None
adj = _get_coords(G, edge_list=True)
g = qtg.GraphItem(pos=G.coords,
adj=adj,
pen=pen,
size=vertex_size / 10)
view.addItem(g)
global _qtg_windows
_qtg_windows.append(window)
elif G.coords.shape[1] == 3:
if not QtGui.QApplication.instance():
QtGui.QApplication([]) # We want only one application.
widget = gl.GLViewWidget()
widget.opts['distance'] = 10
widget.show()
widget.setWindowTitle(title)
if edges:
x, y, z = _get_coords(G)
pos = np.stack((x, y, z), axis=1)
g = gl.GLLinePlotItem(pos=pos,
mode='lines',
color=G.plotting['edge_color'])
widget.addItem(g)
gp = gl.GLScatterPlotItem(pos=G.coords,
size=vertex_size / 3,
color=G.plotting['vertex_color'])
widget.addItem(gp)
global _qtg_widgets
_qtg_widgets.append(widget)
def __init__(self,parent=None):
QtWidgets.QWidget.__init__(self,parent)
self.ui=Ui_normalJoint()
self.ui.setupUi(self)
self.dialog=QtWidgets.QDialog(self)
self.dialog.ui=Ui_normalJointDialog()
self.dialog.ui.setupUi(self.dialog)
self.num=0
self.fingerName='Pinky'
self.jointName='NNNNN'
self.type=0
self.pressure=0
self.angle=0
self.pressureMax=180.0
self.angleMax=120.0
self.weight= [10000 ,1, 1, 1, 1, 1, 1, 1, 1, 1]
self.angleList= [0, 10,20,30,40,50,60,70,80,90,100,110,120]
self.pressureList=[0,27,48,65,79,90,100,109,119,130,145,163,180]
self.model=QtGui.QStandardItemModel(self.dialog.ui.table)
angleItemList=[]
pressureItemList=[]
for angle in self.angleList:
angleItemList.append(QtGui.QStandardItem('{:d}'.format(angle)))
for pressure in self.pressureList:
pressureItemList.append(QtGui.QStandardItem('{:d}'.format(pressure)))
self.model.appendRow(angleItemList)
self.model.appendRow(pressureItemList)
self.model.setHeaderData(0,QtCore.Qt.Vertical,'Angle '+u'\N{DEGREE SIGN}')
self.model.setHeaderData(1,QtCore.Qt.Vertical,'Pressure (KPa)')
self.relationPlotScatter = pg.GraphItem()
self.relationPlotCurve=self.dialog.ui.relationPlotWidget.plot()
v=self.relationPlotCurve.getViewBox()
v.addItem(self.relationPlotScatter)
self.dialog.ui.relationPlotWidget.setLabel('bottom', 'Angle', units=u'\N{DEGREE SIGN}')
self.dialog.ui.relationPlotWidget.setLabel('left', 'Pressure', units='KPa')
self.dialog.ui.table.setModel(self.model)
self.dialog.ui.table.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents)
self.dialog.ui.table.resizeColumnsToContents()
self.model.itemChanged.connect(self.updateAnglePressureRelation)
self.relationPlotScatter.scatter.sigPointDragged.connect(self.slotPointDragged)
self.xarray=np.array(self.angleList)
self.yarray=np.array(self.pressureList)
self.updateAnglePressureRelation(None)
self.dialog.ui.openingMaxP.sigValueChanged.connect(self.slotMaxPChanged)
self.dialog.ui.openingMinP.sigValueChanged.connect(self.slotMinPChanged)
self.dialog.ui.openingMaxN.sigValueChanged.connect(self.slotMaxNChanged)
self.dialog.ui.openingMinN.sigValueChanged.connect(self.slotMinNChanged)
def _qtg_plot_signal(G, signal, edges, vertex_size, limits, title):
qtg, gl, QtGui = _import_qtg()
if G.coords.shape[1] == 2:
widget = qtg.GraphicsLayoutWidget()
view = widget.addViewBox()
elif G.coords.shape[1] == 3:
if not QtGui.QApplication.instance():
QtGui.QApplication([]) # We want only one application.
widget = gl.GLViewWidget()
widget.opts['distance'] = 10
if edges:
if G.coords.shape[1] == 2:
adj = _get_coords(G, edge_list=True)
pen = tuple(np.array(G.plotting['edge_color']) * 255)
g = qtg.GraphItem(pos=G.coords, adj=adj, symbolBrush=None,
symbolPen=None, pen=pen)
view.addItem(g)
elif G.coords.shape[1] == 3:
x, y, z = _get_coords(G)
pos = np.stack((x, y, z), axis=1)
g = gl.GLLinePlotItem(pos=pos, mode='lines',
color=G.plotting['edge_color'])
widget.addItem(g)
pos = [1, 8, 24, 40, 56, 64]
color = np.array([[0, 0, 143, 255], [0, 0, 255, 255], [0, 255, 255, 255],
[255, 255, 0, 255], [255, 0, 0, 255], [128, 0, 0, 255]])
cmap = qtg.ColorMap(pos, color)
signal = 1 + 63 * (signal - limits[0]) / limits[1] - limits[0]
if G.coords.shape[1] == 2:
gp = qtg.ScatterPlotItem(G.coords[:, 0],
G.coords[:, 1],
size=vertex_size/10,
brush=cmap.map(signal, 'qcolor'))
view.addItem(gp)
if G.coords.shape[1] == 3:
gp = gl.GLScatterPlotItem(pos=G.coords,
size=vertex_size/3,
color=cmap.map(signal, 'float'))
widget.addItem(gp)
widget.setWindowTitle(title)
widget.show()
global _qtg_widgets
_qtg_widgets.append(widget)
def initialize(self, Network_UI):
if Network_UI.network['grammar_act', 0] is not None:
self.buffertab = Network_UI.Next_Tab('Buffer')
alphabet = Network_UI.network['grammar_act'][0].alphabet
a_list = [alphabet[i] for i in range(len(alphabet))]
a_list[0] = '_'
ydict = dict(enumerate(a_list))
win = pg.GraphicsWindow()
stringaxis = pg.AxisItem(orientation='left')
stringaxis.setTicks([ydict.items()])
p = Network_UI.Add_plot(axisItems={'left': stringaxis},
x_label='buffer steps')
self.graph = pg.GraphItem()
# p=self.Add_plot('', True)
p.addItem(self.graph)
source = Network_UI.network['grammar_act'][0]
RALN = Reconstruct_Analyze_Label_Network(Network_UI.network)
groups = Network_UI.network[
'prediction_source'] #Network_UI.exc_group_name # , network.NeuronGroups[1]
def update():
RALN.label_and_group_neurons(
Network_UI.network['prediction_source', 0], [
source.get_activation(
char, Network_UI.network['prediction_source', 0])
for char in range(source.get_alphabet_length())
], 'W', 20)
_, self.edges = RALN.visualize_label_and_group_neurons(
x_attribute_name='temporal_layer',
y_attribute_name='class_label',
weight_attribute_name='W',
groups=groups,
weight_limit=None,
n_biggest=1,
source=source,
return_graph=True) # 1/3#None#1/3#0.5
self.nodes = RALN.get_neuron_positions(
Network_UI.network['prediction_source', 0],
x_attribute_name='temporal_layer',
y_attribute_name='class_label',
y_scale=0.0005)
self.update_btn = QPushButton('update live buffers',
Network_UI.main_window)
self.update_btn.clicked.connect(update)
Network_UI.Next_H_Block()
Network_UI.Add_element(self.update_btn)
def setupPlot(self):
self.parseData()
self.lines = pg.GraphItem(pos=np.array([(0, 0)]))
self.plot.addItem(self.lines)
plt = self.plot.getPlotItem()
plt.setXRange(0, 10)
plt.setYRange(0, 10)
plt.showGrid(False, False)
plt.showAxis('left', False)
plt.showAxis('bottom', False)
def get_no_visible_visual_item(self, start, end):
"""
Computes and returns the visual items to represents the groups of no visible elements
:param start: index of the start elements on invisible region
:param end: index of the end elements on invisible region
:return: tuple of (list, list) with the visual elements for the group
of no visible elements in the range [start, end] for oscilogram
and spectrogram widgets respectively
"""
osc_items, spec_items = [], []
# viewRange of plotWidget [[xmin, xmax], [ymin, ymax]]
x_max = self.axesOscilogram.viewRange()[0][1]
start_position = self.get_element(start).indexTo if start > 0 else 0
end_position = self.get_element(
end).indexFrom if end < len(self.elements) - 1 else x_max
max_value = self.signal.maximumValue
widget_scene_width, widget_pixel_width = self.axesOscilogram.viewRect(
).width(), self.axesOscilogram.width() * 1.0
# pixel_visible_text
if (end_position -
start_position) * widget_pixel_width / widget_scene_width > 30:
text = u"(" + unicode(start + 1) + u"..." + unicode(end + 1) + u")" \
if end > start else u"(" + unicode(start + 1) + u")"
text_item = pg.TextItem(text,
color=(255, 255, 255),
anchor=(0.5, 0.5))
text_item.setPos(start_position / 2.0 + end_position / 2.0,
0.75 * max_value)
osc_items.append(text_item)
graph_item = pg.GraphItem()
# Define positions of nodes
graph_pos = np.array([[start_position, max_value * 0.8],
[start_position, max_value * 0.85],
[end_position, max_value * 0.85],
[end_position, max_value * 0.8]])
graph_adj = np.array([[0, 1], [1, 2], [2, 3]])
options = dict(size=1,
symbol='d',
pxMode=False,
pen=self.NO_VISIBLE_ELEMENTS_PEN)
graph_item.setData(pos=graph_pos, adj=graph_adj, **options)
osc_items.append(graph_item)
return osc_items, spec_items
def __init__(self, signal, indexFrom, indexTo, number=0):
VisualElement.__init__(self, number=number, signal=signal,indexFrom=indexFrom, indexTo=indexTo)
self.element_region = pg.GraphItem()
self.element_region.mouseClickEvent = self.mouseClickEvent
# Define positions of nodes
self.element_region_pos = np.array([])
self.element_region_adj = np.array([[0, 1], [1, 2], [2, 3]])
self._update_items_pos()
# update the visual representation
self.visual_figures.append(self.element_region) # item visibility
def plot(self, nodeSize=1):
"""Plot the graph with pyqtgraph. @nodeSize is the dimension of nodes in the plot"""
if not self.plotting:
self.plotting = True
#Create new plot
pg.setConfigOptions(antialias=True)
self.w = pg.GraphicsWindow() #Create a window
self.w.setWindowTitle('Graph plot')
self.v = self.w.addViewBox()
self.v.setAspectLocked()
self.g = pg.GraphItem()
self.v.addItem(self.g)
#Update plot
N = len(self.vertList) #number of vertices
positions = np.zeros((N, 2))
edges = []
weights = []
colors = []
borderColors = []
for i, node in enumerate(self.vertList.values()):
positions[i] = node.position
new_edges = [[i, j] for j in node.getConnections()]
edges.extend(new_edges)
weights.extend(node.getWeights())
colors.append(node.color)
if node.isolated:
borderColors.append(pg.mkPen(color=(0, 0, 255),
width=5)) #Blue border
else:
borderColors.append(pg.mkPen(color=(255, 255, 255),
width=5)) #White border
lines = plt.cm.rainbow(np.array(weights), bytes=True)
self.g.setData(pos=positions,
adj=np.array(edges, dtype=int),
pen=lines,
size=nodeSize,
symbol=['o' for i in range(N)],
symbolBrush=colors,
symbolPen=borderColors,
pxMode=False) #pen=lines #symbolSize=500,
def __init__(self, app, robot):
super(GoalSelectionMaps, self).__init__()
self.main_app = app
self.resetWindow()
self.setWindowTitle("Selection and control")
layout = pg.GraphicsLayout()
self.setCentralItem(layout)
view = layout.addViewBox(row=0,col=0,colspan=1)
self.plot1 = pg.ImageItem(border='w',lut=self.lut)
view.addItem(self.plot1)
view.setAspectLocked(lock=True, ratio=1)
view = layout.addViewBox(row=0,col=1,colspan=1)
self.plot3 = pg.ImageItem(border='w',lut=self.lut)
view.addItem(self.plot3)
view.setAspectLocked(lock=True, ratio=1)
view = layout.addViewBox(row=0,col=2,colspan=1)
self.plot4 = pg.ImageItem(border='w',lut=self.lut)
self.plot6 = pg.ScatterPlotItem()
view.addItem(self.plot4)
view.addItem(self.plot6)
view.setAspectLocked(lock=True, ratio=1)
self.plot5view = layout.addViewBox(row=0,col=3, colspan=2)
self.plot5 = pg.GraphItem()
self.plot5view.addItem(self.plot5)
self.plot2 = layout.addPlot(row=2,col=0, rowspan=3, colspan=5)
view = layout.addViewBox(row=4,col=2)
self.robot = robot
self.curves = []
for g in range(self.robot.gs.N_ECHO_UNITS):
r = np.random.rand()*255
g = np.random.rand()*255
b = np.random.rand()*255
self.curves.append(self.plot2.plot(pen=(r,g,b)))
self.ts_duration = 1
def display_grid(self, data=None):
[height, width] = np.shape(data)
pos = []
adj = []
# vertical lines
x = self.grid_size
index = 0
while (x <= width):
one_edge = [x, 0]
other_edge = [x, height]
pos.append(one_edge)
pos.append(other_edge)
adj.append([index, index + 1])
x += self.grid_size
index += 2
# horizontal lines
y = self.grid_size
while (y <= height):
one_edge = [0, y]
other_edge = [width, y]
pos.append(one_edge)
pos.append(other_edge)
adj.append([index, index + 1])
y += self.grid_size
index += 2
pos = np.array(pos)
adj = np.array(adj)
line_color = (0, 255, 0, 255, 0.5)
lines = np.array([line_color for n in np.arange(len(pos))],
dtype=[('red', np.ubyte), ('green', np.ubyte),
('blue', np.ubyte), ('alpha', np.ubyte),
('width', float)])
# remove old line_view
if self.ui.line_view:
self.ui.image_view.removeItem(self.ui.line_view)
line_view = pg.GraphItem()
self.ui.image_view.addItem(line_view)
line_view.setData(pos=pos,
adj=adj,
pen=lines,
symbol=None,
pxMode=False)
self.ui.line_view = line_view
def __init__(self, lc=None, parent=None, name=None):
super(NetDiagVisWidget, self).__init__(parent)
self.lc = lc
if name:
self.setObjectName(name)
self.plot = pg.PlotWidget(title="Network Health")
self.plot.hideAxis("left")
self.plot.hideAxis("bottom")
self.viewBox = self.plot.getViewBox()
self.graph = pg.GraphItem()
self.viewBox.addItem(self.graph)
self.viewBox.setMouseEnabled(x=False, y=False)
self.node_to_ind_map = {}
self.ind_to_node_list = []
self.next_ind = 0
self.node_pos = np.zeros((0, 2))
self.node_vel = np.zeros((0, 2))
self.color_type = [('red', np.ubyte), ('green', np.ubyte),
('blue', np.ubyte), ('alpha', np.ubyte),
('width', float)]
self.AdjacencyInfo = namedtuple(
'AdjacencyInfo', ('color_type', 'est_rtt', 'est_drop_rate'))
self.adjacency_info_map = {}
self.adjacency_labels = {}
self.node_labels = {}
vBoxLayout = QtGui.QVBoxLayout()
vBoxLayout.addWidget(self.plot)
self.setLayout(vBoxLayout)
nethealth_sub = self.lc.subscribe("_NSUM", self.handle_net_health_t)
self.lastUpdateTime = time.time()
self.update_mutex = Lock()
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.update)
self.timer.start(50)
def __init__(self, toes, *args, **kwargs):
super(rasterPlot, self).__init__(*args, **kwargs)
# if not isinstance(toes, list) or toes.ndim > 1:
# raise ValueError('Event times must be given as ndarray of dimension 2 or less')
n_toes = sum(len(t) for t in toes)
pos = np.zeros((n_toes * 2, 2)) #array of vertex positions
k = 0
for trial_idx, trial_toes in enumerate(toes):
pos[k:k + len(trial_toes) * 2, 0] = trial_toes.repeat(2)
pos[k:k + len(trial_toes) * 2:2, 1] = 1 + trial_idx - .5
pos[k + 1:k + len(trial_toes) * 2:2, 1] = 1 + trial_idx + .5
k += len(trial_toes) * 2
adj = np.arange(n_toes * 2).reshape(n_toes, 2) #connections of graph
self.graph_item = pg.GraphItem(pos=pos, adj=adj, size=0)
self.addItem(self.graph_item)
self.setMouseEnabled(y=False)
def __init__(self):
QDialog.__init__(self)
layout = QGridLayout()
self.setWindowTitle("openDAQ")
impbutton = QPushButton("Import log")
showgraphbtn = QPushButton("show graphs")
clsbutton = QPushButton("Close")
self.tbwidget = QTableWidget()
self.tbwidget.setMinimumHeight(100)
self.tbwidget.setMinimumSize(400, 400)
ScaleUpbtn = QPushButton("Zoom in")
ScaleDownbtn = QPushButton("Zoom Out")
self.FullScreen = QPushButton("Full screen")
#This is what I want but will not work....
self.scene = QGraphicsScene()
self.view = QGraphicsView()
self.view.setMouseTracking(True)
self.view.setScene(self.scene)
self.graphItem = pg.GraphItem()
self.scene.addItem(self.graphItem)
self.view.setMinimumSize(400, 400)
layout.addWidget(self.view, 0, 0)
layout.addWidget(self.tbwidget, 0, 1)
layout.addWidget(clsbutton, 1, 0)
layout.addWidget(impbutton, 2, 0)
layout.addWidget(showgraphbtn, 1, 1)
layout.addWidget(ScaleUpbtn, 3, 0)
layout.addWidget(ScaleDownbtn, 3, 1)
layout.addWidget(self.FullScreen, 2, 1)
self.setLayout(layout)
clsbutton.clicked.connect(self.close)
impbutton.clicked.connect(self.import_data)
showgraphbtn.clicked.connect(self.OpenCharts)
ScaleUpbtn.clicked.connect(self.ScaleViewUp)
ScaleDownbtn.clicked.connect(self.ScaleViewDown)
self.FullScreen.clicked.connect(self.fullscreen)
self.ViewScale = 1
self.view.scale(self.ViewScale, self.ViewScale)
def circle_center_changed(self):
if self.ui.sector_full_circle.isChecked():
if self.sector_g:
self.ui.image_view.removeItem(self.sector_g)
return
x0 = float(self.ui.circle_x.text())
y0 = float(self.ui.circle_y.text())
from_angle = np.float(str(self.ui.sector_from_value.text()))
to_angle = np.float(str(self.ui.sector_to_value.text()))
self.calculate_corners_angles()
self.update_angle_label_position()
[y1, x1] = self.calculate_sector_xy_position(angle=from_angle,
x0=x0,
y0=y0)
[y2, x2] = self.calculate_sector_xy_position(angle=to_angle,
x0=x0,
y0=y0)
pos = np.array([[x0, y0], [x1, y1], [x2, y2]])
adj = np.array([[0, 1], [1, 2], [2, 0]])
symbols = ['+', 'o', 'o']
lines = np.array([(255, 0, 0, 255, 2), (255, 0, 0, 0, 1),
(255, 0, 0, 255, 2)],
dtype=[('red', np.ubyte), ('green', np.ubyte),
('blue', np.ubyte), ('alpha', np.ubyte),
('width', float)])
if self.sector_g:
self.ui.image_view.removeItem(self.sector_g)
self.sector_g = pg.GraphItem()
self.ui.image_view.addItem(self.sector_g)
self.sector_g.setData(pos=pos,
adj=adj,
pen=lines,
size=1,
symbol=symbols,
pxMode=False)
def update_binning_bins(self):
'''
this method takes from the parent file the information necessary to display the selection with
bins in the binning window
'''
pos = self.parent.binning_line_view['pos']
adj = self.parent.binning_line_view['adj']
lines = self.parent.binning_line_view['pen']
line_view_binning = pg.GraphItem()
self.parent.binning_line_view['image_view'].addItem(line_view_binning)
line_view = line_view_binning
line_view.setData(pos=pos,
adj=adj,
pen=lines,
symbol=None,
pxMode=False)
self.parent.binning_line_view['ui'] = line_view
def ceate_tab_pointcloud(self):
# Create tab_pointcloud
tab = QtGui.QTabWidget()
self.addTab(tab, "point cloud")
layout = QtGui.QGridLayout()
tab.setLayout(layout)
gv = pg.GraphicsView()
layout.addWidget(gv, 0, 0, 1, 5)
# Create a viewBox for 2D image
self.vb = pg.ViewBox()
self.vb.setAspectLocked()
gv.setCentralItem(self.vb)
#Create ImageItem for map
button_play = QtGui.QPushButton('Graph optimization')
button_play.setFixedWidth(180)
button_play.clicked.connect(self.handleButton_play)
button_next = QtGui.QPushButton('Next')
button_next.setFixedWidth(110)
button_next.clicked.connect(self.handleButton_next)
layout.addWidget(button_play, 2, 0)
#layout.addWidget(button_next, 2, 1)
self.pcd = pg.ScatterPlotItem(size=3, pen=pg.mkPen(None), brush=pg.mkBrush(255, 255, 255, 120))
self.vb.addItem(self.pcd)
self.cur_scan = pg.ScatterPlotItem(pen = pg.mkPen(None),
brush = pg.mkBrush("g"),
size =5,
antialias = False)
self.vb.addItem(self.cur_scan)
self.robot = RobotItem('b')
#no robot show
#self.robot.setParentItem(self.pcd)
self.robot.scale(0.03,0.03)
self.graph = pg.GraphItem(size=10, symbol="o", symbolPen="w", symbolBrush="y")
self.vb.addItem(self.graph)
def __init__(self,
color=None,
tooltip="",
connect_points=False,
point_figure='+',
points_size=20):
"""
:param color: the color for the lines
:param tooltip: an optional tooltip to show
:return:
"""
SpectralVisualItemWrapper.__init__(self, color=color, tooltip=tooltip)
# time limits
self.indexFrom = 0
self.indexTo = 0
self.points_size = points_size
self.point_figure = point_figure
# 'o' circle, ‘s’ square, ‘t’ triangle, ‘d’ diamond, ‘+’ plus
if point_figure not in ['o', 's', 't', 'd', '+']:
self.point_figure = "+"
# the freq value
self.peak_freq_value = 0
self.connect_points = connect_points
# a line for peak freq
point_positions_list = [[self.indexFrom, self.peak_freq_value]]
if connect_points:
point_positions_list.append([self.indexTo, self.peak_freq_value])
self.peak_freq_pos = np.array(point_positions_list)
self.peak_freq_adj = np.array([[0, 1]])
self.peak_freq_region = pg.GraphItem()
self.peak_freq_region.setToolTip(self.tooltip)
def topology_map_build(self):
"""
Topology map build
:return: Widget with topology map
"""
graphics_widget = pg.GraphicsLayout()
view = graphics_widget.addViewBox(col=0, row=0)
view.setAspectLocked(True)
graph_item = pg.GraphItem()
view.addItem(graph_item)
l_pen = pg.mkPen(color='w', width=1)
graph_item.setPen(l_pen)
label_item = graphics_widget.addLabel(text="Epoch number 0",
col=0,
row=1)
return graphics_widget, graph_item, label_item
def Add_Raster_Channel(self):
# totalNumber = self.dock_area.findAll()
# print(totalNumber)
# dock_index = len(totalNumber[0])
# if len(totalNumber[0]) is 0:
# dock_index = 1
self.raster_counter = self.raster_counter + 1
raster_dock = Dock(
"Raster " + str(self.raster_counter)
) #Figure out how to show the current index of raster
raster_layout = pg.LayoutWidget()
combo2 = QtGui.QComboBox()
for ch_id in range(NCHANNELS):
combo2.addItem("{}".format(ch_id + 1))
raster_layout.addWidget(combo2)
raster_item = pg.GraphItem(symbolPen=self.mypens[0],
symbolBrush=self.mybrush,
symbol='s')
raster_plot = pg.PlotWidget(name="RASTER")
raster_plot.setLimits(xMin=0,
xMax=1,
yMin=0,
yMax=1,
minXRange=1.0,
maxXRange=1.0,
minYRange=1.0,
maxYRange=1.0)
raster_plot.addItem(raster_item)
raster_layout.addWidget(raster_plot)
raster_dock.addWidget(raster_layout)
self.my_rasters.append(raster_item)
self.dock_area3.addDock(raster_dock, position='bottom')
self.raster_buffer.append(np.empty((1, )))
self.get_dock_info()
