def __init__(self, title: str):
self.true_series: QScatterSeries = QScatterSeries()
self.false_series: QScatterSeries = QScatterSeries()
self.chart: QChart = QChart()
self.view: QChartView = QChartView(self.chart)
self.chart.addSeries(self.true_series)
self.chart.addSeries(self.false_series)
self.chart.setTheme(QChart.ChartThemeDark)
self.chart.setMargins(QMargins(0, 0, 0, 0))
self.chart.setBackgroundRoundness(0)
self.chart.legend().hide()
self.chart.layout().setContentsMargins(0, 0, 0, 0)
self.chart.setMaximumHeight(Chart.MAXIMUM_CHART_HEIGHT)
self.true_series.setMarkerShape(QScatterSeries.MarkerShapeRectangle)
self.false_series.setMarkerShape(QScatterSeries.MarkerShapeRectangle)
self.true_series.setColor(Chart.TRUE_COLOR)
self.false_series.setColor(Chart.FALSE_COLOR)
self.chart.createDefaultAxes()
for axis in self.chart.axes(Qt.Horizontal):
axis.setVisible(False)
axis.setGridLineVisible(False)
axis.setRange(0.0, 1000.0)
for axis in self.chart.axes(Qt.Vertical):
axis.setVisible(False)
axis.setGridLineVisible(False)
axis.setRange(-0.5, 0.5)
def __drawParetoChart(self):
def make_noise(value, noise_size):
return value + (noise_size / -2 + noise_size * random.random())
self.__pareto_chart.removeAllSeries()
series1 = QScatterSeries()
series1.setMarkerShape(QScatterSeries.MarkerShapeCircle)
series1.setMarkerSize(5)
series1.append(make_noise(23, 2), make_noise(25, 2))
series1.setBrush(QColor(Qt.red))
self.__pareto_chart.addSeries(series1)
self.__axisy.setRange(0.0, 100.0)
series3 = QScatterSeries()
series3.setName("Точка утопии")
series3.setMarkerShape(QScatterSeries.MarkerShapeCircle)
series3.setMarkerSize(10)
series3.append(make_noise(2, 0.5), make_noise(23, 2))
self.__pareto_chart.addSeries(series3)
series2 = QScatterSeries()
series2.setName("Оптимальный")
series2.setMarkerShape(QScatterSeries.MarkerShapeCircle)
series2.setMarkerSize(7)
series2.append(make_noise(2, 0.5), make_noise(45, 4))
self.__pareto_chart.addSeries(series2)
self.__pareto_chart.setAxisX(self.__axisx, series1)
self.__pareto_chart.setAxisY(self.__axisy, series1)
self.__pareto_chart.setAxisX(self.__axisx, series2)
self.__pareto_chart.setAxisY(self.__axisy, series2)
self.__pareto_chart.setAxisX(self.__axisx, series3)
self.__pareto_chart.setAxisY(self.__axisy, series3)
def plot_live_data(self): #plot graph
if self.forceData.force_filepath == "": #area plot only
if self.frameCount != 1: #ignore for image
self.plotWindow.liveChart.removeAllSeries()
self.plotWindow.liveChartScene.removeItem(self.plotWindow.liveChart)
self.plotWindow.liveChartView.resetCachedContent()
self.plotWindow.liveChart = QChart() #live chart
self.plotWindow.liveChart.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.plotWindow.liveChart.legend().hide()
logging.debug('%s', self.plotWindow.liveChartView.size())
w, h = (self.plotWindow.liveChartView.size().width(),
self.plotWindow.liveChartView.size().height())
logging.debug('%s, %s', w,h)
self.plotWindow.liveChart.setMinimumSize(w, h)
self.curve1 = QScatterSeries()#initialise live plot curves
self.initialise_live_plot(self.curve1, Qt.blue) #contact area plot
logging.debug('%s', self.frameTime.shape)
data_ind = "Contact angle" \
if self.analysisMode.currentText() == "Contact Angle Analysis" \
else "Contact area"
for k in self.roiDict.keys():
if len(self.roiDict.keys()) > 1 and k == "Default":
continue
self.curve1.append(self.series_to_polyline(self.frameTime,
self.dataDict[k][data_ind]))
self.plotWindow.liveChart.addSeries(self.curve1)
if self.roi_auto == True: # roi area plot
self.curve2 = QScatterSeries()
self.initialise_live_plot(self.curve2, Qt.red)
for k in self.roiDict.keys():
if len(self.roiDict.keys()) > 1 and k == "Default":
continue
self.curve2.append(self.series_to_polyline(self.frameTime,
self.dataDict[k]["ROI area"]))
self.plotWindow.liveChart.addSeries(self.curve2)
self.plotWindow.liveChart.createDefaultAxes()
self.plotWindow.liveChartScene.addItem(self.plotWindow.liveChart)
self.plotWindow.liveChartView.setScene(self.plotWindow.liveChartScene)
logging.debug("live plot end")
elif self.forceData.plotWidget.fig_close == False: #area and force plot
self.forceData.getArea(self.frameTime, self.dataDict)
# self.forceData.plotData(self.lengthUnit.currentText())
# self.forceData.toggleAnimation(True)
self.forceData.plotImageAnimate(int(self.framePos))
def setupChart(self):
"""Set up the GUI's series and chart."""
# Collect x and y data values from the CSV file
x_values, y_values = self.loadCSVFile()
# Get the largest x and y values; Used for setting the chart's axes
x_max, y_max = max(x_values), max(y_values)
# Create numpy arrays from the x and y values
x_values = np.array(x_values)
y_values = np.array(y_values)
# Calculate the regression line
coefficients = linearRegression(x_values, y_values)
# Create chart object
chart = QChart()
chart.setTitle("Auto Insurance for Geographical Zones in Sweden")
chart.legend().hide()
# Create scatter series and add points to the series
scatter_series = QScatterSeries()
scatter_series.setName("DataPoints")
scatter_series.setMarkerSize(9.0)
scatter_series.hovered.connect(self.displayPointInfo)
for value in range(0, self.row_count - 1):
scatter_series.append(x_values[value], y_values[value])
scatter_series.setBorderColor(QColor('#000000'))
# Create line series and add points to the series
line_series = QLineSeries()
line_series.setName("RegressionLine")
# Calculate the regression line
for x in x_values:
y_pred = coefficients[0] + coefficients[1] * x
line_series.append(x, y_pred)
# Add both series to the chart and create x and y axes
chart.addSeries(scatter_series)
chart.addSeries(line_series)
chart.createDefaultAxes()
axis_x = chart.axes(Qt.Horizontal)
axis_x[0].setTitleText("Number of Claims")
axis_x[0].setRange(0, x_max)
axis_x[0].setLabelFormat("%i")
axis_y = chart.axes(Qt.Vertical)
axis_y[0].setTitleText(
"Total Payment in Swedish Kronor (in thousands)")
axis_y[0].setRange(0, y_max + 20)
# Create QChartView object for displaying the chart
chart_view = QChartView(chart)
v_box = QVBoxLayout()
v_box.addWidget(chart_view)
self.setLayout(v_box)
def chart_init(self,s_key):
self.chart = QChart()
self.x_Aix = QDateTimeAxis()#定义x轴，实例化
#self.x_Aix.setRange(52665,52765)
#self.x_Aix.setLabelFormat("%0.2f")
self.x_Aix.setFormat("hh:mm:ss")
self.x_Aix.setTickCount(6)
#self.x_Aix.setTickCount(6)
#self.x_Aix.setMinorTickCount(0)
self.y_Aix = QValueAxis()#定义y轴
#self.y_Aix.setRange(-50,50)
self.y_Aix.setLabelFormat("%0.2f")
#self.y_Aix.setTickCount(6)
self.y_Aix.setMinorTickCount(0)
self.chart.addAxis(self.x_Aix,Qt.AlignBottom)
self.chart.addAxis(self.y_Aix,Qt.AlignLeft)
self.s_key = s_key
self.series_list={}
color_list = [QColor("blue"),QColor("green"),QColor("red"),QColor(152,245,255),QColor(84,255,159),QColor(255,193,193)]
for k,c in zip(self.s_key,color_list):
self.q_point[k] = queue.Queue()
self.series_list[k] = QScatterSeries()
self.series_list[k].setMarkerSize(9.0)
self.series_list[k].setColor(QColor(c))
self.series_list[k].setPen(QPen(QtCore.Qt.PenStyle.NoPen))
self.chart.addSeries(self.series_list[k])
self.series_list[k].setName(k)
self.series_list[k].attachAxis(self.x_Aix)
self.series_list[k].attachAxis(self.y_Aix)
self.setChart(self.chart)
def update_particles(particles):
animation_chart = QChart()
reals = QScatterSeries()
pen_reals = reals.pen()
pen_reals.setBrush(QtGui.QColor("white"))
reals.setMarkerSize(5)
reals.setColor(QtGui.QColor("red"))
reals.setPen(pen_reals)
for particle in particles:
reals.append(particle, 0)
animation_chart.addSeries(reals)
animation_chart.setBackgroundBrush(QtGui.QColor(41, 43, 47))
animation_chart.createDefaultAxes()
animation_chart.legend().hide()
animation_chart.setContentsMargins(-10, -10, -10, -10)
animation_chart.layout().setContentsMargins(0, 0, 0, 0)
animation_chart.axisX().setTickCount(17)
animation_chart.axisY().setTickCount(3)
animation_chart.axisX().setLabelsColor(QtGui.QColor("white"))
animation_chart.axisX().setGridLineColor(QtGui.QColor("grey"))
animation_chart.axisX().setRange(-4, 12)
animation_chart.axisY().setRange(-1, 1)
animation_chart.axisY().setLabelsColor(QtGui.QColor("white"))
animation_chart.axisY().setGridLineColor(QtGui.QColor("grey"))
form.widget_animation.setChart(animation_chart)
def chart_init(self):
self.chart = QChart()
self.series = QScatterSeries()
#设置曲线名称
self.series.setName("实时数据")
self.series.setColor(QColor(255,0,0))
self.series.setMarkerSize(20.0)
self.series.setPen(QPen(QtCore.Qt.PenStyle.NoPen))
#把曲线添加到QChart的实例中
self.chart.addSeries(self.series)
#声明并初始化X轴，Y轴
self.dtaxisX = QDateTimeAxis()
self.vlaxisY = QValueAxis()
#设置坐标轴显示范围
self.dtaxisX.setMin(QDateTime.currentDateTime().addSecs(-300*1))
self.dtaxisX.setMax(QDateTime.currentDateTime().addSecs(0))
self.vlaxisY.setMin(0)
self.vlaxisY.setMax(1500)
#设置X轴时间样式
self.dtaxisX.setFormat("MM月dd hh:mm:ss")
#设置坐标轴上的格点
self.dtaxisX.setTickCount(6)
self.vlaxisY.setTickCount(11)
#设置坐标轴名称
self.dtaxisX.setTitleText("时间")
self.vlaxisY.setTitleText("量程")
#设置网格不显示`
#把坐标轴添加到chart中
self.chart.addAxis(self.dtaxisX,Qt.AlignBottom)
self.chart.addAxis(self.vlaxisY,Qt.AlignLeft)
#把曲线关联到坐标轴
self.series.attachAxis(self.dtaxisX)
self.series.attachAxis(self.vlaxisY)
self.setChart(self.chart)
def getSeries(self, chart):
for i, data_list in enumerate(self.m_dataTable):
series = QScatterSeries(chart)
for value, _ in data_list:
series.append(value)
series.setName('Series ' + str(i))
chart.addSeries(series)
def __init__(self, landmarkPoints, allPoints, threadEvent):
super().__init__()
self.title = "Lidar data points"
#self.queue = queue
self.color = Qt.darkRed
self.lmrkPoints = landmarkPoints
self.allPoints = allPoints
self.event = threadEvent
self.left = 500
self.top = 500
self.height = 480
self.width = 640
self.count = 0
self.time = 0
self.label = QLabel(self)
self.lmrkBox = QCheckBox("Landmark points", self)
self.ptsBox = QCheckBox("Data points", self)
self.boxArea = QWidget()
self.mainLayout = QGridLayout()
self.mainLayout.addWidget(self.lmrkBox, 0, 0)
self.mainLayout.addWidget(self.ptsBox, 1, 0)
self.mainLayout.setVerticalSpacing(5)
self.boxArea.setLayout(self.mainLayout)
crote = QDockWidget("Hide", self)
crote.setWidget(self.boxArea)
self.addDockWidget(Qt.LeftDockWidgetArea, crote)
dock = QDockWidget("", self)
dock.setWidget(self.label)
self.addDockWidget(Qt.LeftDockWidgetArea, dock)
self.chart = QChart()
self.config_axis()
self.series = QScatterSeries(self.chart)
self.allSeries = QScatterSeries(self.chart)
self.config_series()
#self.update()
self.timer = QTimer(self)
self.view = QChartView(self.chart)
self.setCentralWidget(
self.view
) # It is needed to create to view because the CentralWidget needs to be a QWidget, and a QChart is not so.
self.initWindow()
def __init__(self, name):
self.name = name
self.chart_view = QChartView()
self.price_time_axis = QDateTimeAxis()
self.price_time_axis.setFormat('h:mm')
self.price_axis = QValueAxis()
self.candle_stick_series = QCandlestickSeries()
self.candle_stick_series.setIncreasingColor(Qt.red)
self.candle_stick_series.setDecreasingColor(Qt.blue)
self.moving_average_series = QLineSeries()
self.top_edge_series = QScatterSeries()
self.bottom_edge_series = QScatterSeries()
self.trend_lines = []
self.short_top_trend_series = QLineSeries()
self.short_bottom_trend_series = QLineSeries()
self.long_top_trend_series = QLineSeries()
self.long_bottom_trend_series = QLineSeries()
self.trend_lines.append(self.short_top_trend_series)
self.trend_lines.append(self.short_bottom_trend_series)
self.trend_lines.append(self.long_top_trend_series)
self.trend_lines.append(self.long_bottom_trend_series)
self.chart_view.chart().addSeries(self.candle_stick_series)
self.chart_view.chart().addSeries(self.moving_average_series)
self.chart_view.chart().addSeries(self.top_edge_series)
self.chart_view.chart().addSeries(self.bottom_edge_series)
self.chart_view.chart().addSeries(self.short_top_trend_series)
self.chart_view.chart().addSeries(self.long_top_trend_series)
self.chart_view.chart().addSeries(self.short_bottom_trend_series)
self.chart_view.chart().addSeries(self.long_bottom_trend_series)
self.chart_view.chart().addAxis(self.price_time_axis, Qt.AlignBottom)
self.chart_view.chart().addAxis(self.price_axis, Qt.AlignLeft)
self.chart_view.chart().legend().hide()
self.chart_view.setRenderHint(QPainter.Antialiasing)
self.set_marker_color()
self.set_trend_line_pen()
def createScatterChart(self):
chart = QChart()
chart.setTitle("Scatter chart")
for i, data_list in enumerate(self.m_dataTable):
series = QScatterSeries(chart)
for value, _ in data_list:
series.append(value)
series.setName("Series " + str(i))
chart.addSeries(series)
chart.createDefaultAxes()
return chart
def addSeries(self, _x2idx: typing.Dict, _idx2x: list, _chart: QChart,
_axis_x: QValueAxis, _axis_y: QValueAxis):
series = QScatterSeries()
series.setName(self.name)
for x, y in zip(self.x_list, self.y_list):
series.append(_x2idx[x], y)
if self.color is not None:
series.setColor(self.color)
_chart.addSeries(series)
_chart.setAxisX(_axis_x, series)
_chart.setAxisY(_axis_y, series)
if self.show_value:
self.createShow()
def setAddScatterSerie(self, color):
self.scatterCurve.append(QScatterSeries())
pen = self.scatterCurve[len(self.scatterCurve) - 1].pen()
pen.setColor(QColor(color))
pen.setWidthF(1)
self.scatterCurve[len(self.scatterCurve) - 1].setPen(pen)
self.scatterCurve[len(self.scatterCurve) - 1].setColor(QColor(color))
self.scatterCurve[len(self.scatterCurve) - 1].setMarkerSize(10)
self.chart.addSeries(self.scatterCurve[len(self.scatterCurve) - 1])
self.chart.setAxisX(self.axisX,
self.scatterCurve[len(self.scatterCurve) - 1])
self.chart.setAxisY(self.axisY,
self.scatterCurve[len(self.scatterCurve) - 1])
def XScatterSeries(data_dict, key_order = None, xkey = None, openGL=False):
'''
the first dict in the key_order will be used as the x-axis
'''
if key_order==None:
key_order = data_dict.keys()
series = []
if xkey == None:
xkey = list(key_order)[0]
for key in key_order-xkey:
set = QScatterSeries(); set.setName(key)
if openGL:
set.setUseOpenGL(True)
for i, (itemx, itemy) in enumerate(zip_longest(data_dict[xkey],data_dict[key])):
set.append(itemx, itemy)
series.append(set)
return series
def appendScatterSeries(self, name, list_x, list_y):
ls = QScatterSeries()
ls.setName(name)
self.series.append(ls)
for i in range(len(list_x)):
x = float(list_x[i])
y = float(list_y[i])
ls.append(x, y)
if self.maxy == None: #Gives first maxy and miny
self.maxy = y * 1.01
self.miny = y * 0.99
self.maxx = x * 1.01
self.minx = x * 0.99
if y > self.maxy:
self.maxy = y
if y < self.miny:
self.miny = y
if x > self.maxx:
self.maxx = x
if x < self.minx:
self.minx = x
def _init_train_points(self):
self._train_points = None
self._train_scatter_series = QScatterSeries()
init_series(self._train_scatter_series, QColor(255, 0, 0))
self._chart.addSeries(self._train_scatter_series)
def setVideoParam(self): #set video parameters
## self.count_frames() #count number of frames by loop
# self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
self.frameCount = self.countThread.frameCount
# self.frameWidth = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
# self.frameHeight = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
# self.frameCount = len(self.cap)
self.frameHeight, self.frameWidth, _ = self.cap.frame_shape
self.framePos = 1
try:
self.fpsSpinBox.setValue(self.cap.frame_rate)
except Exception as e:
logging.warning(f'{e}')
logging.debug('%s, %s, %s', self.frameCount, self.frameWidth, self.frameRate)
roiCorners = np.array([[0, 0],[self.frameWidth, 0],
[self.frameWidth, self.frameHeight],
[0, self.frameHeight]],np.int32)
self.roiBound = [0, 0, self.frameWidth, self.frameHeight]
#roi dictionary: actual roi, bound, contours, adjusted roi, auto roi
self.roiDict = {"Default": [roiCorners, self.roiBound,
[], roiCorners, roiCorners]}
self.frameBackground = 255 * np.ones((self.frameHeight,
self.frameWidth, 3),dtype=np.uint8)
self.bgframeNumber = None
# self.ret, self.frame = self.cap.read()
# if self.ret == False: #reset video on error
# logging.debug("if")
# self.cap.release()
# self.cap = cv2.VideoCapture(self.videoPath)
# self.ret, self.frame = self.cap.read()
self.frame = self.cap[0]
self.renderVideo("Raw", self.frame)
self.effectScene.removeItem(self.effectPixmapItem)
self.effectPixmapItem = self.effectScene.addPixmap(self.blankPixmap)
self.effectView.fitInView(self.effectPixmapItem, 1)
# self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
self.frame_current = self.frame.copy()
#Frame no. ROI label, contour id, area, length, ecc, array
self.contour_data = [[], [], [], [], [], [], [], []]
# contactArea = np.zeros(int(self.frameCount), np.float64)
# contactLength = np.zeros(int(self.frameCount), np.float64)
# contourNumber = np.zeros(int(self.frameCount), np.uint64)
# roiArea = np.zeros(int(self.frameCount), np.float64)
# roiLength = np.zeros(int(self.frameCount), np.float64)
# eccAvg = np.zeros(int(self.frameCount), np.float64) #median eccentricity
# contactAngle = np.zeros(int(self.frameCount), np.float64)
# self.dataDict = {"Default" : {"Contact area": contactArea,
# "Contact length": contactLength,
# "Contact number": contourNumber,
# "ROI area": roiArea,
# "ROI length": roiLength,
# "Eccentricity": eccAvg,
# "Ellipse fit": [[(0,0),(0,0),0,1]]*int(self.frameCount),
# "Contact angle": contactAngle}
# }
self.dataDict = {}
self.init_datadict("Default") #initialize self.dataDict
self.frameTime = np.linspace(0,
self.frameCount/self.frameRate,
int(self.frameCount), dtype = np.float64)
self.effectChain = [True, False, False, False] #b/c, hist, bg sub, filter
## self.roi_auto = self.threshROIGroupBox.isChecked()
self.distinct_roi = self.distinctAutoROI.isChecked()
self.roi_hull = self.applyHullROI.isChecked()
self.combine_roi = self.combineROI.isChecked()
self.roi_tresh_type = "Global"
self.tresh_size_roi = self.threshROISpinBox1.value()
self.tresh_cst_roi = self.threshROISpinBox2.value()
self.blur_size_roi = self.blurROISpinBox.value()
self.bg_roi_apply = self.applybgROI.isChecked()
self.bg_blur_size_roi = self.bgblurROISpinBox.value()
self.bg_blend_roi = self.bgblendROISpinBox.value()
# self.framePos = 0
self.roi_min_area = self.roiMinSpinBox.value()
self.epsilon_fraction = 10**(self.epsilonSpinBox.value())
self.roi_morph = self.morphROI.isChecked()
self.x_roi_morph = self.morphXSpinBox.value()
self.y_roi_morph = self.morphYSpinBox.value()
self.calibFactor = self.lengthValue.value()/self.pixelValue.value()
self.definePaths()
self.seekSlider.blockSignals(True)
self.seekSlider.setValue(1)
self.seekSlider.setTickInterval(int(0.2 *self.frameCount))
self.seekSlider.setSingleStep(int(0.1 *self.frameCount))
self.seekSlider.setMaximum(int(self.frameCount))
self.seekSlider.blockSignals(False)
self.analyzeVideo.blockSignals(True)
self.analyzeVideo.setChecked(False)
self.analyzeVideo.blockSignals(False)
self.dftGroupBox.blockSignals(True)
self.dftGroupBox.setChecked(False)
self.dftGroupBox.blockSignals(False)
self.bgGroupBox.blockSignals(True)
self.bgGroupBox.setChecked(False)
self.bgGroupBox.blockSignals(False)
self.threshROIGroupBox.blockSignals(True)
self.threshROIGroupBox.setChecked(False)
self.threshROIGroupBox.blockSignals(False)
## self.distinctAutoROI.setEnabled(False)
self.roi_auto = False
self.segment = self.segmentGroupBox.isChecked()
self.show_segment = self.showSegment.isChecked()
self.show_fg = self.segmentFGButton.isChecked()
self.show_bg = self.segmentBGButton.isChecked()
## self.distinct_roi = False
## self.distinctAutoROI.blockSignals(True)
## self.distinctAutoROI.setChecked(False)
## self.distinctAutoROI.blockSignals(False)
# self.correctZeroForce.blockSignals(True)
# self.correctZeroForce.setChecked(False)
# self.correctZeroForce.blockSignals(False)
self.analyzeDataWindow.zero_subtract.setChecked(False)
self.analyzeDataWindow.zero_subtract.setEnabled(False)
self.rawViewTab.setTabEnabled(1,False)
# self.showContours.setEnabled(False)
# self.showEffect.setEnabled(False)
# self.forceData = ForceAnal(self.fitWindow, self.configPlotWindow,
# self.analyzeDataWindow)
# self.zeroForceData = ForceAnal() #initalise
# self.correctZeroForce.setEnabled(False)
self.clearData.setEnabled(True)
# self.videoEffect.setCurrentIndex(0) CHECK TAB DISABLE!
# self.videoEffect.model().item(5).setEnabled(False)
# self.videoEffect.model().item(6).setEnabled(True)
self.effectViewTab.setTabEnabled(4,False)
# self.effectViewTab.setTabEnabled(6,True)
self.videoFileNameLabel.setText("<b>Video file:</b>\n" + self.videoPath) #video path
# self.forceFileNameLabel.setText("Select force data from file menu")
# self.zeroForceFileNameLabel.setText("Select zero-force data from file menu")
## self.statusBar.showMessage("Frame number: " + str(int(self.framePos)) + "\t("
## + str(int((self.framePos)*100/self.frameCount)) +
## "%)")
self.statusBar.showMessage(str(int(self.frameCount)) + " frames loaded!")
self.configRecWindow.videoTextbox.setText("")
self.init_dict() #initialise dictionaries
# self.framePos = 1 #avoid array indexing issue
self.frame_bin_roi_full = None
self.curve1 = QScatterSeries()#initialise live plot curves
self.curve2 = QScatterSeries()
self.initialise_live_plot(self.curve1, Qt.blue) #contact area plot
self.initialise_live_plot(self.curve2, Qt.red) # roi area plot
self.msrmnt_num = None
self.setWindowTitle(self.appVersion)
if self.msrListMode == True: #continue loading force data etc
self.load_measurement_data()
def __init__(self, parent=None):
super(AmzHistoryChart, self).__init__(parent=parent)
self.dbsession = Session()
self.context_menu_actions = []
self._avg_pointspan = 0
self._max_points = 100
self.source = None
self.history = None
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
# Set up the chart
self.chart_view = QChartView(self)
self.chart_view.setRenderHint(QPainter.Antialiasing)
self.chart_view.setContextMenuPolicy(Qt.CustomContextMenu)
self.chart_view.customContextMenuRequested.connect(self.context_menu)
self.chart = QChart()
self.chart.legend().hide()
self.chart.setFlags(QGraphicsItem.ItemIsFocusable | QGraphicsItem.ItemIsSelectable)
self.chart.installEventFilter(self)
self.chart_view.setChart(self.chart)
self.layout().addWidget(self.chart_view)
# Create the axes
rcolor = QColor(50, 130, 220)
pcolor = QColor(0, 200, 0)
ocolor = QColor(255, 175, 0)
self.timeAxis = QDateTimeAxis()
self.timeAxis.setFormat('M/dd hh:mm')
self.timeAxis.setTitleText('Date/Time')
self.chart.addAxis(self.timeAxis, Qt.AlignBottom)
self.timeAxis.minChanged.connect(self.on_timeaxis_min_changed)
self.rankAxis = QValueAxis()
self.rankAxis.setLabelFormat('%\'i')
self.rankAxis.setTitleText('Sales Rank')
self.rankAxis.setLinePenColor(rcolor)
self.rankAxis.setLabelsColor(rcolor)
self.chart.addAxis(self.rankAxis, Qt.AlignLeft)
self.priceAxis = QValueAxis()
self.priceAxis.setLabelFormat('$%.2f')
self.priceAxis.setTitleText('Price')
self.priceAxis.setLinePenColor(pcolor)
self.priceAxis.setLabelsColor(pcolor)
self.chart.addAxis(self.priceAxis, Qt.AlignRight)
# Create the series
self.rankLine = QLineSeries()
self.chart.addSeries(self.rankLine)
self.rankLine.attachAxis(self.timeAxis)
self.rankLine.attachAxis(self.rankAxis)
self.rankLine.setColor(rcolor)
self.priceLine = QLineSeries()
self.chart.addSeries(self.priceLine)
self.priceLine.attachAxis(self.timeAxis)
self.priceLine.attachAxis(self.priceAxis)
self.priceLine.setColor(pcolor)
self.salesPoints = QScatterSeries()
self.chart.addSeries(self.salesPoints)
self.salesPoints.attachAxis(self.timeAxis)
self.salesPoints.attachAxis(self.rankAxis)
self.salesPoints.setColor(ocolor)
def onPlotButtonClicked(self, packets=None):
if self.chart:
self.chart.removeAllSeries()
if packets is None:
packets = self.data
if not packets:
return
self.showMessage('Preparing plot ...')
name = self.paramNameEdit.text()
packet_selection = self.comboBox.currentIndex()
xaxis_type = self.xaxisComboBox.currentIndex()
data_type = self.dataTypeComboBox.currentIndex()
timestamp = []
self.y = []
params = self.paramNameEdit.text()
header = packets[0]['header']
current_spid = 0
spid_text = self.spidLineEdit.text()
if spid_text:
current_spid = int(spid_text)
selected_packets=[]
if packet_selection == 0:
selected_packets=[packets[self.current_row]]
elif packet_selection == 1:
selected_packets=packets
for packet in selected_packets:
header = packet['header']
if packet['header']['SPID'] != current_spid:
continue
params = packet['parameters']
self.walk(name, params, header, timestamp, self.y, xaxis_type,
data_type)
self.x = []
if not self.y:
self.showMessage('No data points')
elif self.y:
style = self.styleEdit.text()
if not style:
style = '-'
title = '%s' % str(name)
desc = self.descLabel.text()
if desc:
title += '- %s' % desc
self.chart.setTitle(title)
ylabel = 'Raw value'
xlabel = name
if data_type == 1:
ylabel = 'Engineering / Decompressed value'
if xaxis_type == 0:
if packet_selection == 1:
xlabel = "Packet #"
else:
xlabel = "Repeat #"
self.x = range(0, len(self.y))
if xaxis_type == 1:
self.x = [t - timestamp[0] for t in timestamp]
xlabel = 'Time -T0 (s)'
if xaxis_type != 2:
series = QLineSeries()
series2 = None
for xx, yy in zip(self.x, self.y):
series.append(xx, yy)
if 'o' in style:
series2 = QScatterSeries()
for xx, yy in zip(self.x, self.y):
series2.append(xx, yy)
self.chart.addSeries(series2)
self.chart.addSeries(series)
axisX = QValueAxis()
axisX.setTitleText(xlabel)
axisY = QValueAxis()
axisY.setTitleText(ylabel)
self.chart.setAxisX(axisX)
self.chart.setAxisY(axisY)
series.attachAxis(axisX)
series.attachAxis(axisY)
else:
nbins = len(set(self.y))
ycounts, xedges = np.histogram(self.y, bins=nbins)
series = QLineSeries()
for i in range(0, nbins):
meanx = (xedges[i] + xedges[i + 1]) / 2.
series.append(meanx, ycounts[i])
self.chart.addSeries(series)
axisX = QValueAxis()
axisX.setTitleText(name)
axisY = QValueAxis()
axisY.setTitleText("Counts")
self.chart.setAxisY(axisY)
self.chart.setAxisX(axisX)
series.attachAxis(axisX)
series.attachAxis(axisY)
self.xlabel = xlabel
self.ylabel = ylabel
self.chartView.setRubberBand(QChartView.RectangleRubberBand)
self.chartView.setRenderHint(QtGui.QPainter.Antialiasing)
msg = 'Number of data points: {}, Ymin: {}, Ymax: {}'.format(
len(self.y), min(self.y), max(self.y))
self.showMessage(msg, 1)
self.showMessage('The canvas updated!')
def onPlotButtonClicked(self):
if self.chart:
self.chart.removeAllSeries()
if not self.data:
return
self.showMessage('Preparing plot ...')
name = self.paramNameEdit.text()
packet_selection = self.comboBox.currentIndex()
xaxis_type = self.xaxisComboBox.currentIndex()
data_type = self.dataTypeComboBox.currentIndex()
timestamp = []
self.y = []
packet_id = self.current_row
params = self.data[packet_id]['parameters']
header = self.data[packet_id]['header']
current_spid=header['SPID']
if packet_selection == 0:
self.walk(
name,
params,
header,
timestamp,
self.y,
xaxis_type,
data_type)
elif packet_selection == 1:
for packet in self.data:
header = packet['header']
if packet['header']['SPID'] != current_spid:
continue
#only look for parameters in the packets of the same type
params = packet['parameters']
self.walk(
name,
params,
header,
timestamp,
self.y,
xaxis_type,
data_type)
self.x = []
if not self.y:
self.showMessage('No data points')
elif self.y:
style = self.styleEdit.text()
if not style:
style = '-'
title = '%s' % str(name)
desc = self.descLabel.text()
if desc:
title += '- %s' % desc
self.chart.setTitle(title)
ylabel = 'Raw value'
xlabel = name
if data_type == 1:
ylabel = 'Engineering value'
if xaxis_type == 0:
xlabel = "Packet #"
self.x = range(0, len(self.y))
if xaxis_type == 1:
self.x = [t - timestamp[0] for t in timestamp]
xlabel = 'Time -T0 (s)'
#if xaxis_type != 2:
if True:
series = QLineSeries()
series2 = None
# print(y)
# print(x)
for xx, yy in zip(self.x, self.y):
series.append(xx, yy)
if 'o' in style:
series2 = QScatterSeries()
for xx, yy in zip(self.x, self.y):
series2.append(xx, yy)
self.chart.addSeries(series2)
self.chart.addSeries(series)
self.showMessage('plotted!')
#self.chart.createDefaultAxes()
axisX = QValueAxis()
axisX.setTitleText(xlabel)
axisY = QValueAxis()
axisY.setTitleText(ylabel)
self.chart.setAxisX(axisX)
self.chart.setAxisY(axisY)
series.attachAxis(axisX)
series.attachAxis(axisY)
# histogram
#else:
# nbins = len(set(self.y))
# ycounts, xedges = np.histogram(self.y, bins=nbins)
# series = QLineSeries()
# for i in range(0, nbins):
# meanx = (xedges[i] + xedges[i + 1]) / 2.
# series.append(meanx, ycounts[i])
# # series.append(dataset)
# self.chart.addSeries(series)
# #self.chart.createDefaultAxes()
# self.showMessage('Histogram plotted!')
# axisX = QValueAxis()
# axisX.setTitleText(name)
# axisY = QValueAxis()
# axisY.setTitleText("Counts")
# self.chart.setAxisY(axisY)
# self.chart.setAxisX(axisX)
## series.attachAxis(axisX)
# series.attachAxis(axisY)
# self.widget.setChart(self.chart)
self.xlabel=xlabel
self.ylabel=ylabel
self.chartView.setRubberBand(QChartView.RectangleRubberBand)
self.chartView.setRenderHint(QtGui.QPainter.Antialiasing)
def run_evolution():
range_a = float(str(form.input_a.text()))
range_b = float(str(form.input_b.text()))
precision = int(str(form.input_d.text()))
generations_number = int(str(form.input_t.text()))
app.setOverrideCursor(QtCore.Qt.WaitCursor)
best_reals, best_binary, best_fxs, local_fxs, _, _ = evolution(range_a, range_b, precision, generations_number, form.checkBox.isChecked())
form.best_table.item(1,0).setText(str(best_reals[len(local_fxs)-1]))
form.best_table.item(1,1).setText(''.join(map(str, best_binary[len(local_fxs)-1])))
form.best_table.item(1,2).setText(str(best_fxs[len(local_fxs)-1]))
chart = QChart()
bests = QLineSeries()
pen_best = bests.pen()
pen_best.setWidth(1)
pen_best.setBrush(QtGui.QColor("red"))
bests.setPen(pen_best)
for i in range(0, len(local_fxs)):
if len(local_fxs[i]) - 1 == 0:
fxs = QScatterSeries()
fxs.append(i + 0.99, local_fxs[i][0])
pen = fxs.pen()
color = QtGui.QColor(random.randint(50,255), random.randint(50,255), random.randint(50,255))
fxs.setColor(color)
pen.setColor(color)
fxs.setPen(pen)
fxs.setMarkerSize(5)
else:
fxs = QLineSeries()
tick = 1 / (len(local_fxs[i]) - 1)
for j in range(len(local_fxs[i])):
fxs.append(i + j * tick, local_fxs[i][j])
pen = fxs.pen()
pen.setWidth(1)
pen.setBrush(QtGui.QColor(random.randint(50,255), random.randint(50,255), random.randint(50,255)))
fxs.setPen(pen)
bests.append(i+1, best_fxs[i])
chart.addSeries(fxs)
chart.addSeries(bests)
chart.setBackgroundBrush(QtGui.QColor(41, 43, 47))
chart.createDefaultAxes()
chart.legend().hide()
chart.setContentsMargins(-10, -10, -10, -10)
chart.layout().setContentsMargins(0, 0, 0, 0)
chart.axisX().setTickCount(11)
chart.axisX().setLabelsColor(QtGui.QColor("white"))
chart.axisX().setGridLineColor(QtGui.QColor("grey"))
chart.axisX().setLabelFormat("%i")
chart.axisY().setRange(-2,2)
chart.axisY().setLabelsColor(QtGui.QColor("white"))
chart.axisY().setGridLineColor(QtGui.QColor("grey"))
form.widget.setChart(chart)
with open('best_history.csv', 'w', newline='', encoding='utf8') as history_csvfile:
history_writer = csv.writer(
history_csvfile, delimiter=';', dialect=csv.excel)
history_writer.writerow(['Parametry'])
history_writer.writerow(['Precyzja: 10^-%d' % precision])
history_writer.writerow(['Iteracje: %d' % generations_number])
history_writer.writerow(['', 'real', 'bin', 'f(real)'])
for index, generation in enumerate(range(generations_number)):
history_writer.writerow([index, best_reals[generation], best_binary[generation], best_fxs[generation]])
app.restoreOverrideCursor()
def setData(self, timeData, valueData, chartTypes="Bar"):
axisX = QDateTimeAxis()
axisX.setFormat("yyyy-MM-dd")
if self.chartTypes == "Bar":
# Clear all series
self.clearAll()
self.zoomSeries = QLineSeries(self.chart())
barSeries = QBarSeries(self.chart())
barset = QBarSet("data")
barSeries.setBarWidth(0.8)
barSeries.append(barset)
for td, vd in zip(timeData, valueData):
self.zoomSeries.append(td.toMSecsSinceEpoch(), vd)
barset.append(valueData)
self.zoomSeries.hide()
self.chart().addSeries(self.zoomSeries)
self.chart().addSeries(barSeries)
self.chart().setAxisY(QValueAxis(), self.zoomSeries)
axisX.setRange(min(timeData), max(timeData))
self.chart().setAxisX(axisX, self.zoomSeries)
elif self.chartTypes == "Scatter":
# Clear all series
self.clearAll()
self.zoomSeries = QLineSeries(self.chart())
scattSeries = QScatterSeries(self.chart())
scattSeries.setMarkerSize(8)
for td, vd in zip(timeData, valueData):
self.zoomSeries.append(td.toMSecsSinceEpoch(), vd)
scattSeries.append(td.toMSecsSinceEpoch(), vd)
self.zoomSeries.hide()
self.chart().addSeries(self.zoomSeries)
self.chart().addSeries(scattSeries)
self.chart().setAxisY(QValueAxis(), self.zoomSeries)
axisX.setRange(min(timeData), max(timeData))
self.chart().setAxisX(axisX, self.zoomSeries)
elif self.chartTypes in ["Line", "PLine"]:
self.clearAll()
if self.chartTypes == "Line":
self.zoomSeries = QLineSeries(self.chart())
else:
self.zoomSeries = QSplineSeries(self.chart())
for td, vd in zip(timeData, valueData):
self.zoomSeries.append(td.toMSecsSinceEpoch(), vd)
self.chart().addSeries(self.zoomSeries)
self.chart().setAxisY(QValueAxis(), self.zoomSeries)
axisX.setRange(min(timeData), max(timeData))
self.chart().setAxisX(axisX, self.zoomSeries)
elif self.chartTypes == "Area":
self.clearAll()
self.zoomSeries = QLineSeries()
self.zoomSeries.setColor(QColor("#666666"))
for td, vd in zip(timeData, valueData):
self.zoomSeries.append(td.toMSecsSinceEpoch(), vd)
areaSeries = QAreaSeries(self.zoomSeries, None)
self.chart().addSeries(self.zoomSeries)
self.chart().addSeries(areaSeries)
self.chart().setAxisY(QValueAxis(), areaSeries)
axisX.setRange(min(timeData), max(timeData))
self.chart().setAxisX(axisX, areaSeries)
self.zoomSeries.hide()
self.mintimeData = min(timeData)
self.maxtimeData = max(timeData)
self.BtnsWidget.dateRangeEdit.setDateRange([
self.mintimeData.toString("yyyy-MM-dd"),
self.maxtimeData.toString("yyyy-MM-dd"),
])
self.updateView()
for (min, max), axis in zip(axisRanges, axisList):
axis.setRange(min, max)
newChart.setTitle(oldChart.title())
self.setChart(newChart)
app = QApplication(sys.argv)
ANGULAR_MIN = -100
ANGULAR_MAX = 100
RADIAL_MIN = -100
RADIAL_MAX = 100
series1 = QScatterSeries()
series1.setName("scatter")
for i in range(ANGULAR_MIN, ANGULAR_MAX + 1, 10):
series1.append(i, (float(i) / RADIAL_MAX) * RADIAL_MAX + 8.0)
series2 = QSplineSeries()
series2.setName("spline")
for i in range(ANGULAR_MIN, ANGULAR_MAX + 1, 10):
series2.append(i, (float(i) / RADIAL_MAX) * RADIAL_MAX)
series3 = QLineSeries()
series3.setName("star outer")
ad = (ANGULAR_MAX - ANGULAR_MIN) / 8.0
rd = (RADIAL_MAX - RADIAL_MIN) / 3.0 * 1.3
series3.append(ANGULAR_MIN, RADIAL_MAX)
series3.append(ANGULAR_MIN + ad * 1, RADIAL_MIN + rd)
def __createChart(self): ##创建图表
chart = QChart() #创建 Chart
## chart.setTitle("简单函数曲线")
chart.legend().setVisible(True)
self.chartView.setChart(chart) #Chart添加到chartView
pen=QPen()
pen.setWidth(2)
##========LineSeries折线 和 ScatterSeries散点
seriesLine = QLineSeries()
seriesLine.setName("LineSeries折线")
seriesLine.setPointsVisible(False) #数据点不可见
pen.setColor(Qt.red)
seriesLine.setPen(pen)
seriesLine.hovered.connect(self.do_series_hovered) #信号 hovered
seriesLine.clicked.connect(self.do_series_clicked) #信号 clicked
chart.addSeries(seriesLine) #添加到chart
seriesLinePoint = QScatterSeries() #散点序列
seriesLinePoint.setName("ScatterSeries散点")
shape=QScatterSeries.MarkerShapeCircle #MarkerShapeRectangle
seriesLinePoint.setMarkerShape(shape) #散点形状，只有2种
seriesLinePoint.setBorderColor(Qt.yellow)
seriesLinePoint.setBrush(QBrush(Qt.red))
seriesLinePoint.setMarkerSize(10) #散点大小
seriesLinePoint.hovered.connect(self.do_series_hovered) #信号 hovered
seriesLinePoint.clicked.connect(self.do_series_clicked) #信号 clicked
chart.addSeries(seriesLinePoint) #添加到chart
##======== SplineSeries 曲线和 QScatterSeries 散点
seriesSpLine = QSplineSeries()
seriesSpLine.setName("SplineSeries曲线")
seriesSpLine.setPointsVisible(False) #数据点不可见
pen.setColor(Qt.blue)
seriesSpLine.setPen(pen)
seriesSpLine.hovered.connect(self.do_series_hovered) #信号 hovered
seriesSpLine.clicked.connect(self.do_series_clicked) #信号 clicked
seriesSpPoint = QScatterSeries() #散点序列
seriesSpPoint.setName("QScatterSeries")
shape=QScatterSeries.MarkerShapeRectangle #MarkerShapeCircle
seriesSpPoint.setMarkerShape(shape) #散点形状，只有2种
seriesSpPoint.setBorderColor(Qt.green)
seriesSpPoint.setBrush(QBrush(Qt.blue))
seriesSpPoint.setMarkerSize(10) #散点大小
seriesSpPoint.hovered.connect(self.do_series_hovered) #信号 hovered
seriesSpPoint.clicked.connect(self.do_series_clicked) #信号 clicked
chart.addSeries(seriesSpLine)
chart.addSeries(seriesSpPoint)
## 创建缺省坐标轴
chart.createDefaultAxes() #创建缺省坐标轴并与序列关联
chart.axisX().setTitleText("time(secs)")
chart.axisX().setRange(0,10)
chart.axisX().applyNiceNumbers()
chart.axisY().setTitleText("value")
chart.axisY().setRange(-2,2)
chart.axisY().applyNiceNumbers()
for marker in chart.legend().markers(): #QLegendMarker类型列表
marker.clicked.connect(self.do_LegendMarkerClicked)
def create_graphs(self):
"""
Creates the graphs that will be displayed int the dashboard's Graphs tab.
:return: None
"""
global default_comboBox_graph_item_count
# Set Graphs ComboBox
for x in range(self.comboBox_rings.count()):
self.comboBox_rings.removeItem(default_comboBox_graph_item_count)
for x in range(self.comboBox_wedges.count()):
self.comboBox_wedges.removeItem(default_comboBox_graph_item_count)
self.comboBox_rings.setCurrentIndex(0)
self.comboBox_wedges.setCurrentIndex(0)
# Ring Graph
self.ring_chart = QChart()
for x in range(len(self.densities)):
ring_series = QLineSeries()
for y in range(len(self.densities[x])-1):
ring_series.append(y+1, self.densities[x][y])
self.ring_chart.addSeries(ring_series)
if x < len(self.densities)-1:
self.comboBox_rings.addItem("Ring " + str(x+1))
self.ring_chart.setTitle('Fiber Density VS Wedges')
self.ring_chart.legend().hide()
self.ring_chart.createDefaultAxes()
self.ring_chart.axes(Qt.Horizontal)[0].setRange(1, len(self.densities[0])-1)
self.ring_chart.axes(Qt.Vertical)[0].setRange(0, 1)
self.ring_chart.axes(Qt.Horizontal)[0].setTitleText("Wedge Number")
self.ring_chart.axes(Qt.Vertical)[0].setTitleText("Fiber Density")
self.chartView = QChartView(self.ring_chart, self.widget_rings)
self.chartView.resize(self.widget_rings.size())
# Wedges Graph
self.wedge_chart = QChart()
for y in range(len(self.densities[0])):
if in_data['num_rings'] == 1:
ring_series = QScatterSeries()
else:
ring_series = QLineSeries()
for x in range(len(self.densities)-1):
ring_series.append(x+1, self.densities[x][y])
self.wedge_chart.addSeries(ring_series)
if y < len(self.densities[0])-1:
self.comboBox_wedges.addItem("Wedge " + str(y+1))
self.wedge_chart.setTitle('Fiber Density VS Rings')
self.wedge_chart.legend().hide()
self.wedge_chart.createDefaultAxes()
if (len(self.densities)) == 2:
self.wedge_chart.axes(Qt.Horizontal)[0].setRange(0, 2)
else:
self.wedge_chart.axes(Qt.Horizontal)[0].setRange(1, len(self.densities)-1)
self.wedge_chart.axes(Qt.Vertical)[0].setRange(0, 1)
self.wedge_chart.axes(Qt.Horizontal)[0].setTitleText("Ring Number")
self.wedge_chart.axes(Qt.Vertical)[0].setTitleText("Fiber Density")
self.chartView = QChartView(self.wedge_chart, self.widget_wedges)
self.chartView.resize(self.widget_wedges.size())
self.widget_rings.show()
self.widget_wedges.show()
if in_data['num_rings'] == 1:
self.comboBox_rings.hide()
else:
self.comboBox_rings.show()
self.comboBox_wedges.show()
def appendScatterSeries(self, name):
ls = QScatterSeries()
ls.setName(name)
self.series.append(ls)
return ls
