def _appendToBrowser(self, style, text):
"""Convert text to HTML for inserting it to browser. Insert the HTML
"""
text = html.escape(text)
text = text.replace('\n', '<br/>')
defBg = self._browser.palette().color(QPalette.Base)
h, s, v, a = defBg.getHsvF()
if style == 'out':
pass
elif style == 'in':
if v > 0.5: # white background
v = v - (v / 8) # make darker
else:
v = v + ((1 - v) / 4) # make ligher
elif style == 'err':
if v < 0.5: # dark background
v = v + ((1 - v) / 4) # make ligher
h = 0
s = .4
elif style == 'hint':
if v < 0.5: # dark background
v = v + ((1 - v) / 4) # make ligher
h = 0.33
s = .4
else:
assert 0
bg = QColor.fromHsvF(h, s, v)
text = '<span style="background-color: %s;">%s</span>' % (bg.name(), text)
scrollBar = self._browser.verticalScrollBar()
oldValue = scrollBar.value()
if False:
# hlamer: It seems, it is more comfortable, if text is always scrolled
scrollAtTheEnd = oldValue == scrollBar.maximum()
else:
scrollAtTheEnd = True
self._browser.moveCursor(QTextCursor.End)
self._browser.insertHtml(text)
if scrollAtTheEnd:
scrollBar.setValue(scrollBar.maximum())
else:
scrollBar.setValue(oldValue)
while self._browser.document().characterCount() > 1024 * 1024:
cursor = self._browser.cursorForPosition(QPoint(0, 0))
cursor.select(cursor.LineUnderCursor)
if not cursor.selectedText():
cursor.movePosition(cursor.Down, cursor.KeepAnchor)
cursor.movePosition(cursor.EndOfLine, cursor.KeepAnchor)
cursor.removeSelectedText()
def updateBasesPerRepeat(self, step_size: int):
"""Recreates colors, all vhi
Args:
step_size: Description
"""
hue_scale = step_size*self.HUE_FACTOR
self._colors = [QColor.fromHsvF(i / hue_scale, 0.75, 0.8).name()
for i in range(int(step_size))]
def _getColors(self):
"""Summary
Returns:
TYPE: Description
"""
step_size = int(self.virtual_helix_item.getProperty('bases_per_repeat'))
hue_scale = step_size*self.HUE_FACTOR
return [QColor.fromHsvF(i / hue_scale, 0.75, 0.8).name() for i in range(step_size)]
def updateBasesPerRepeat(self, step_size):
"""Recreates colors, all vhi
Args:
step_size (TYPE): Description
"""
hue_scale = step_size * self.HUE_FACTOR
self._colors = [
QColor.fromHsvF(i / hue_scale, 0.75, 0.8).name()
for i in range(step_size)
]
def __init__(self, parent):
super().__init__(parent)
self.instrumentOpagueBackground = QBrush(
QColor.fromHsvF(0, 0, 0.3, 1.0))
self.instrumentBackground = QBrush(QColor.fromHsvF(0, 0, 0.3, 0.3))
self.instrumentEdgePen = QPen(QColor.fromHsvF(0, 0, 0.65, 0.5))
self.font = QFont()
self.lineWidth = 2
self.fineLineWidth = 1
self.navigationTargetBearing = PrimaryFlightDisplay.UNKNOWN_ATTITUDE
self.navigationCrosstrackError = 0
self.primaryAltitude = PrimaryFlightDisplay.UNKNOWN_ALTITUDE
self.GPSAltitude = PrimaryFlightDisplay.UNKNOWN_ALTITUDE
self.verticalVelocity = PrimaryFlightDisplay.UNKNOWN_ALTITUDE
self.primarySpeed = PrimaryFlightDisplay.UNKNOWN_SPEED
self.groundspeed = PrimaryFlightDisplay.UNKNOWN_SPEED
self.roll = 0.0
self.pitch = 0.0
self.yaw = 0.0
self.rollspeed = 0.0
self.pitchspeed = 0.0
self.yawspeed = 0.0
self.latitude = 0.0
self.longitude = 0.0
self.additionalParameters = {}
self.param = UserData.getInstance().getUserDataEntry(UD_PFD_KEY, {})
self.isGPSSpeedPrimary = UserData.getParameterValue(
self.param, UD_PFD_PRIMARY_SPEED_SOURCE_KEY) == 'GPS'
self.isGPSAltitudePrimary = UserData.getParameterValue(
self.param, UD_PFD_PRIMARY_ALTITUDE_SOURCE_KEY) == 'GPS'
self.setMinimumSize(480, 320)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.smallTestSize = self.SMALL_TEXT_SIZE
self.mediumTextSize = self.MEDIUM_TEXT_SIZE
self.largeTextSize = self.LARGE_TEXT_SIZE
self.uiTimer = QTimer(self)
self.uiTimer.setInterval(40)
self.uiTimer.timeout.connect(self.update)
self.uas = None
def onTick(self):
t = Time.time
hue = math.fmod(t / 10, 1)
c = QColor.fromHsvF(hue, 1., .5)
glClearColor(c.redF(), c.greenF(), c.blueF(), 1)
# c, s = math.cos(t), math.sin(t)
# v_offset = self.v_offset
# v_offset[0][0] = c; v_offset[0][1] = s
# v_offset[1][0] = c; v_offset[1][1] = s
# v_offset[2][0] = c; v_offset[2][1] = s
self.updateGL()
def onTick(self):
t = Time.time
hue = math.fmod(t / 10, 1)
c = QColor.fromHsvF(hue, 1., .5)
glClearColor(c.redF(), c.greenF(), c.blueF(), 1)
# c, s = math.cos(t), math.sin(t)
# v_offset = self.v_offset
# v_offset[0][0] = c; v_offset[0][1] = s
# v_offset[1][0] = c; v_offset[1][1] = s
# v_offset[2][0] = c; v_offset[2][1] = s
self.updateGL();
def _getColors(self):
"""Summary
Returns:
TYPE: Description
"""
step_size = self.virtual_helix_item.getProperty('bases_per_repeat')
hue_scale = step_size * self.HUE_FACTOR
return [
QColor.fromHsvF(i / hue_scale, 0.75, 0.8).name()
for i in range(step_size)
]
def distance_to_color(self, distance) -> QColor:
"""
Computes a QColor given some temporal distance value. Takes into account
the current min_heat and max_heat.
"""
heat_range = self.max_heat - self.min_heat
out = QColor.fromHsvF(
min(max(distance - self.min_heat, 0), heat_range) /
((heat_range) * 1.5), 1,
1 - min(max(distance - self.min_heat, 0), heat_range) /
(heat_range) / 2, 0.5)
return out
def paintGL(self):
super(self.__class__, self).paintGL()
program = self.program
program.use()
self.vao.bind()
t = Time.time
program.a['offset_vs'](math.cos(t) / 2, math.sin(t) / 2)
c = QColor.fromHsvF(math.fmod(t / math.pi, 1), 1, .5)
program.a['color_vs'](c.redF(), c.greenF(), c.blueF())
glDrawArrays(GL_PATCHES, 0, 3)
glFlush()
def getColor(colorAttr):
'''Return the QColor of a dot color attribute.
Argument(s):
colorAttr (str): Color attribute
'''
if StringUtils.isStrBetweenDoubleQuotes(colorAttr):
# Remove double quotes
colorAttr = colorAttr[1:-1].strip()
# Hexa to QColor
if NodeDotColorUtils.isHexaColor(colorAttr):
return QColor(colorAttr)
# Color name to QColor
if NodeDotColorUtils.colorNameExists(colorAttr):
return QColor(NodeDotColorUtils.dictColorNamesHexa[colorAttr])
# Transparent color
if NodeDotColorUtils.isTransparentColor(colorAttr):
return QColor(Qt.transparent)
# HSV to QColor
if NodeDotColorUtils.isHSVColor(colorAttr):
hsv = re.findall(realNumberPattern,
colorAttr)
return QColor.fromHsvF(float(hsv[0]), float(hsv[1]),
float(hsv[2]))
# Color list
if NodeDotColorUtils.isColorList(colorAttr):
return QColor(Qt.black)
# In this case, we can only have a color name
else:
if NodeDotColorUtils.colorNameExists(colorAttr):
return QColor(NodeDotColorUtils.dictColorNamesHexa[colorAttr])
# Transparent color
if NodeDotColorUtils.isTransparentColor(colorAttr):
return QColor(Qt.transparent)
# Normaly whe should never reach this case
return None
def getColor(colorAttr):
'''Return the QColor of a dot color attribute.
Argument(s):
colorAttr (str): Color attribute
'''
if StringUtils.isStrBetweenDoubleQuotes(colorAttr):
# Remove double quotes
colorAttr = colorAttr[1:-1].strip()
# Hexa to QColor
if NodeDotColorUtils.isHexaColor(colorAttr):
return QColor(colorAttr)
# Color name to QColor
if NodeDotColorUtils.colorNameExists(colorAttr):
return QColor(NodeDotColorUtils.dictColorNamesHexa[colorAttr])
# Transparent color
if NodeDotColorUtils.isTransparentColor(colorAttr):
return QColor(Qt.transparent)
# HSV to QColor
if NodeDotColorUtils.isHSVColor(colorAttr):
hsv = re.findall(DotAttrsUtils.realNumberPattern, colorAttr)
return QColor.fromHsvF(float(hsv[0]), float(hsv[1]),
float(hsv[2]))
# Color list
if NodeDotColorUtils.isColorList(colorAttr):
return QColor(Qt.black)
# In this case, we can only have a color name
else:
if NodeDotColorUtils.colorNameExists(colorAttr):
return QColor(NodeDotColorUtils.dictColorNamesHexa[colorAttr])
# Transparent color
if NodeDotColorUtils.isTransparentColor(colorAttr):
return QColor(Qt.transparent)
# Normaly whe should never reach this case
return None
def _create_linear_gradient(self) -> None:
self._gradient_widget.setAutoFillBackground(True)
gradient = QLinearGradient()
gradient.setStart(self._gradient_widget.width(), 0.0)
gradient.setFinalStop(self._gradient_widget.width(),
self._gradient_widget.height())
# Create gradient stops
stops = []
i = 0.0
for i in range(360):
stop_location = i / 360.0
color = QColor.fromHsvF(i / 360.0, 1.0, 0.8)
stop = (stop_location, color)
stops.append(stop)
gradient.setStops(stops)
# Add Gradient to the rectangle
brush = QtGui.QBrush(gradient)
palette = self._gradient_widget.palette()
palette.setBrush(self._gradient_widget.backgroundRole(), brush)
self._gradient_widget.setPalette(palette)
def onColorBaseChanged(self, x, y, z):
if self.updating: return
hue, s, v = z, x, 1.0 - y
color = QColor.fromHsvF(hue, s, v)
color.setAlphaF(self.currentColor.alphaF())
self.setColor(color)
def setDefaultClass(self, cls):
self._default_class = cls
if self._model != None:
(hue, sat, val) = self._model.hsvF(self._default_class)
self._bbox_pen = QPen(QColor.fromHsvF(hue, sat, val), 2)
from PyQt5.QtCore import (QLineF, QPointF, QRectF, Qt, QTimer)
from PyQt5.QtGui import (QBrush, QColor, QPen, QPainter, QPainterPath,
QIntValidator, QPixmap, QTransform, QCursor)
from PyQt5.QtWidgets import (QApplication, QWidget, QMainWindow, QGraphicsView,
QGraphicsScene, QGraphicsItem, QGraphicsRectItem,
QGraphicsPixmapItem, qApp, QLabel, QLineEdit,
QSizePolicy)
import pickle
import math
#ビューのサイズ
viewheight = 300
viewwidth = 300
#バーの色
announcebarColor = QColor.fromHsvF(145 / 360, 1, 1)
announcebarPen = QPen(announcebarColor)
announcebarBrush = QBrush(announcebarColor)
withdrawbarColor = QColor.fromHsvF(15 / 360, 1, 1)
withdrawbarPen = QPen(withdrawbarColor)
withdrawbarBrush = QBrush(withdrawbarColor)
barWidth = 10
timeRange = 50 #分数
announceFile = "a.0802241824-0802241923.pickle"
withdrawFile = "w.0802241824-0802241923.pickle"
#アクティビティバープロット(トポロジ全体)
class ActivityPlotView(QGraphicsView):
def __init__(self, height=50, width=100, size=5):
super(ActivityPlotView, self).__init__()
def current_color(self):
return QColor.fromHsvF(
self.device.keyboard.underglow_color[0] / 255.0,
self.device.keyboard.underglow_color[1] / 255.0,
self.device.keyboard.underglow_brightness / 255.0)
def current_color(self):
return QColor.fromHsvF(self.keyboard.rgb_hsv[0] / 255.0,
self.keyboard.rgb_hsv[1] / 255.0, 1.0)
def onTick(self):
c = QColor.fromHsvF(math.fmod(Time.time / 10, 1), 1, 0.5)
glClearColor(c.redF(), c.greenF(), c.blueF(), 1)
super().onTick()
def paintGL(self):
theta = Time.time / 10
c = QColor.fromHsvF(math.fmod(self.id / 25. + theta, 1), 1., .5)
glClearColor(c.redF(), c.greenF(), c.blueF(), .5)
super(self.__class__, self).paintGL()
QIntValidator, QPixmap, QTransform, QCursor)
from PyQt5.QtWidgets import (QApplication, QWidget, QMainWindow, QGraphicsView,
QGraphicsScene, QGraphicsItem,
QGraphicsEllipseItem, QGraphicsPixmapItem, qApp,
QLabel, QLineEdit, QSizePolicy)
import networkx as nx
import csv
#ビューのサイズ
viewheight = 600
viewwidth = 900
overalledges = []
overallWithdrawedges = []
nodeColor = QColor.fromHsvF(330 / 360, 0.4, 1)
nodeColor.setAlpha(127)
nodeBrush = QBrush(nodeColor)
gridWidth = 0.01
nodeGridPen = QPen(nodeColor)
nodeGridPen.setWidthF(gridWidth)
edgePen = QPen(QColor(0, 0, 255, 127))
withdrawedgePen = QPen(QColor(255, 0, 0, 127))
#時間窓数 * 15分(9: TTNet, 4:youtube)
timeWindowNumber = 4
#timeWindowNumber = 9
targetdir = "YoutubePakistan/"
#targetdir = "TTNet/"
def _getColorB(transparency) -> QColor:
return QColor.fromHsvF(0, 0, transparency / 100)
def drawAIGlobalFeatures(self, painter, mainArea, paintArea):
painter.resetTransform()
painter.translate(mainArea.center())
pitchPixels = self.pitchAngleToTranslation(mainArea.height(),
self.pitch)
gradientEnd = self.pitchAngleToTranslation(mainArea.height(), 60)
if math.isnan(self.roll) == False: # check for NaN
painter.rotate(-self.roll)
painter.translate(0, pitchPixels)
# Calculate the radius of area we need to paint to cover all.
rtx = painter.transform().inverted()[0]
topLeft = rtx.map(paintArea.topLeft())
topRight = rtx.map(paintArea.topRight())
bottomLeft = rtx.map(paintArea.bottomLeft())
bottomRight = rtx.map(paintArea.bottomRight())
# Just KISS... make a rectangluar basis.
minx = self.min4(topLeft.x(), topRight.x(), bottomLeft.x(),
bottomRight.x())
maxx = self.max4(topLeft.x(), topRight.x(), bottomLeft.x(),
bottomRight.x())
miny = self.min4(topLeft.y(), topRight.y(), bottomLeft.y(),
bottomRight.y())
maxy = self.max4(topLeft.y(), topRight.y(), bottomLeft.y(),
bottomRight.y())
hzonLeft = QPoint(minx, 0)
hzonRight = QPoint(maxx, 0)
skyPath = QPainterPath(hzonLeft)
skyPath.lineTo(QPointF(minx, miny))
skyPath.lineTo(QPointF(maxx, miny))
skyPath.lineTo(hzonRight)
skyPath.closeSubpath()
# TODO: The gradient is wrong now.
skyGradient = QLinearGradient(0, -gradientEnd, 0, 0)
skyGradient.setColorAt(0, QColor.fromHsvF(0.6, 1.0, 0.7))
skyGradient.setColorAt(1, QColor.fromHsvF(0.6, 0.25, 0.9))
skyBrush = QBrush(skyGradient)
painter.fillPath(skyPath, skyBrush)
groundPath = QPainterPath(hzonRight)
groundPath.lineTo(maxx, maxy)
groundPath.lineTo(minx, maxy)
groundPath.lineTo(hzonLeft)
groundPath.closeSubpath()
groundGradient = QLinearGradient(0, gradientEnd, 0, 0)
groundGradient.setColorAt(0, QColor.fromHsvF(0.25, 1, 0.5))
groundGradient.setColorAt(1, QColor.fromHsvF(0.25, 0.25, 0.5))
groundBrush = QBrush(groundGradient)
painter.fillPath(groundPath, groundBrush)
pen = QPen()
pen.setWidthF(self.lineWidth)
pen.setColor(QColor(0, 255, 0))
painter.setPen(pen)
start = QPointF(-mainArea.width(), 0)
end = QPoint(mainArea.width(), 0)
painter.drawLine(start, end)
def DeepColor(value, color=QColor(Qt.red)): # h:0.0为红色
h, s, v, a = color.getHsvF()
return QColor.fromHsvF(h, s, v, value)
def onTick(self):
c = QColor.fromHsvF(math.fmod(Time.time / 10, 1), 1, 0.5)
glClearColor(c.redF(), c.greenF(), c.blueF(), 1)
super().onTick()
def update_slider(self):
'''
Update the slider to a gradient between the two colors.
The painting of the slider comes from the program Krita. The original code can be accessed
at the following URL.
https://github.com/KDE/krita/blob/master/plugins/dockers/advancedcolorselector/kis_shade_selector_line.cpp
'''
if self.need_redraw:
patch_count = self.width()
base_hsva = list(
self.docker.managedcolor_to_qcolor(self.left_color).getHsvF())
dest_hsva = list(
self.docker.managedcolor_to_qcolor(self.right_color).getHsvF())
diff_hsva = [(dest_hsva[i] - base_hsva[i]) for i in range(4)]
if dest_hsva[0] == -1.0:
diff_hsva[0] = 0
elif base_hsva[0] == -1.0:
diff_hsva[0] = 0
base_hsva[0] = dest_hsva[0]
elif diff_hsva[
0] > 0.5: # make sure the sliding goes through a minor arc
diff_hsva[0] = diff_hsva[0] - 1.0
elif diff_hsva[0] < -0.5:
diff_hsva[0] = diff_hsva[0] + 1.0
step_hsva = [x / patch_count for x in diff_hsva]
self.slider_pixmap = QPixmap(self.width(), self.height())
painter = QPainter(self.slider_pixmap)
for i in range(patch_count):
hue = base_hsva[0] + i * step_hsva[0]
while hue < 0.0:
hue += 1.0
while hue > 1.0:
hue -= 1.0
saturation = base_hsva[1] + i * step_hsva[1]
value = base_hsva[2] + i * step_hsva[2]
cur_color = QColor.fromHsvF(hue, saturation, value)
painter.fillRect(i, 0, 1, self.height(), cur_color)
painter.end()
self.need_redraw = False
widget_painter = QPainter(self)
self.rendered_image = self.slider_pixmap.toImage()
widget_painter.drawImage(0, 0, self.rendered_image)
if self.value_x is not None:
start_x = self.value_x
start_y = self.height() / 2
delta_x = self.height() / 3
delta_y = self.height() / 3
points = [
QPoint(start_x, start_y),
QPoint(start_x - delta_x, start_y + delta_y),
QPoint(start_x + delta_x, start_y + delta_y)
]
widget_painter.setBrush(QBrush(self.cursor_fill_color))
widget_painter.setPen(self.cursor_outline_color)
widget_painter.drawPolygon(QPolygon(points))
