def _add(c1: QColor, c2: QColor) -> QColor:
return QColor(
_clampcolor(c1.red() + c2.red()),
_clampcolor(c1.green() + c2.green()),
_clampcolor(c1.blue() + c2.blue()),
_clampcolor(c1.alpha() + c2.alpha()),
)
class SelectionModel:
def __init__(self):
self.view = None
self.map = None
self.points = []
self.fig_points = []
self.marker_colour = QColor(255, 0, 0)
self.text_colour = QColor(0, 0, 255)
def getCanvas(self):
return self.view.figure.canvas
def getAxes(self):
return self.view.figure.axes[0]
def getMarkerColour(self):
return (self.marker_colour.red() / 255,
self.marker_colour.green() / 255,
self.marker_colour.blue() / 255)
def getTextColour(self):
return (self.text_colour.red() / 255, self.text_colour.green() / 255,
self.text_colour.blue() / 255)
def isEnabled(self):
return self.view is not None and not sip.isdeleted(self.view)
def _blendColor_(self, base: QColor, overlay: QColor, stage: int):
assert 0 <= stage <= self.FADE_STAGES, f"Invalid stage: {stage}, expected [0..{self.FADE_STAGES}]"
ratio = stage / self.FADE_STAGES
red = base.red()*(1-ratio) + overlay.red()*ratio
green = base.green()*(1-ratio) + overlay.green()*ratio
blue = base.blue()*(1-ratio) + overlay.blue()*ratio
return QColor(red, green, blue)
def toJson(self):
# Qt.red ecc are integers
bg = QColor(self._backgroundColor)
pl = QColor(self._poleColor)
cc = QColor(self._cartColor)
return {
'backgroundColor': {
'r': bg.red(),
'g': bg.green(),
'b': bg.blue(),
},
'cartColor': {
'r': cc.red(),
'g': cc.green(),
'b': cc.blue(),
},
'cartWidth': self._cartWidth,
'poleColor': {
'r': pl.red(),
'g': pl.green(),
'b': pl.blue(),
},
'showAngleTolerance': self._showAngleTolerance
}
def blend_colors(color1: QtGui.QColor, color2: QtGui.QColor,
ratio: float) -> int:
return QtGui.qRgb(
int(color1.red() * (1 - ratio) + color2.red() * ratio),
int(color1.green() * (1 - ratio) + color2.green() * ratio),
int(color1.blue() * (1 - ratio) + color2.blue() * ratio),
)
def get_repeat_count(c1: QColor, c2: QColor):
delta = [
c1.red() - c2.red(),
c1.green() - c2.green(),
c1.blue() - c2.blue()
]
count = int(math.sqrt(delta[0]**2 + delta[1]**2 + delta[2]**2))
return count
def paintEvent(self, evt):
"""
Protected method handling a paint event.
@param evt reference to the paint event (QPaintEvent)
"""
if self.__privateMode:
backgroundColor = QColor(220, 220, 220) # light gray
foregroundColor = Qt.black
else:
backgroundColor = QApplication.palette().color(QPalette.Base)
foregroundColor = QApplication.palette().color(QPalette.Text)
if self.__browser is not None:
p = self.palette()
progress = self.__browser.progress()
if progress == 0 or progress == 100:
if self.__browser.url().scheme() == "https":
if QSslCertificate is not None:
if self.__browser.page().hasValidSslInfo():
backgroundColor = Preferences.getHelp(
"SaveUrlColor")
else:
backgroundColor = Preferences.getHelp("SaveUrlColor")
p.setBrush(QPalette.Base, backgroundColor)
p.setBrush(QPalette.Text, foregroundColor)
else:
if self.__browser.url().scheme() == "https":
if QSslCertificate is not None:
if self.__browser.page().hasValidSslInfo():
backgroundColor = Preferences.getHelp(
"SaveUrlColor")
else:
backgroundColor = Preferences.getHelp("SaveUrlColor")
highlight = QApplication.palette().color(QPalette.Highlight)
r = (highlight.red() + 2 * backgroundColor.red()) // 3
g = (highlight.green() + 2 * backgroundColor.green()) // 3
b = (highlight.blue() + 2 * backgroundColor.blue()) // 3
loadingColor = QColor(r, g, b)
if abs(loadingColor.lightness() -
backgroundColor.lightness()) < 20:
# special handling for special color schemes (e.g Gaia)
r = (2 * highlight.red() + backgroundColor.red()) // 3
g = (2 * highlight.green() + backgroundColor.green()) // 3
b = (2 * highlight.blue() + backgroundColor.blue()) // 3
loadingColor = QColor(r, g, b)
gradient = QLinearGradient(
QPointF(0, 0), QPointF(self.width(), 0))
gradient.setColorAt(0, loadingColor)
gradient.setColorAt(progress / 100.0 - 0.000001, loadingColor)
gradient.setColorAt(progress / 100.0, backgroundColor)
p.setBrush(QPalette.Base, gradient)
self.setPalette(p)
E5LineEdit.paintEvent(self, evt)
def paintEvent(self, evt):
"""
Protected method handling a paint event.
@param evt reference to the paint event (QPaintEvent)
"""
if self.__privateMode:
backgroundColor = QColor(220, 220, 220) # light gray
foregroundColor = Qt.black
else:
backgroundColor = QApplication.palette().color(QPalette.Base)
foregroundColor = QApplication.palette().color(QPalette.Text)
if self.__browser is not None:
p = self.palette()
progress = self.__browser.progress()
if progress == 0 or progress == 100:
if self.__browser.url().scheme() == "https":
if QSslCertificate is not None:
if self.__browser.page().hasValidSslInfo():
backgroundColor = Preferences.getHelp(
"SaveUrlColor")
else:
backgroundColor = Preferences.getHelp("SaveUrlColor")
p.setBrush(QPalette.Base, backgroundColor)
p.setBrush(QPalette.Text, foregroundColor)
else:
if self.__browser.url().scheme() == "https":
if QSslCertificate is not None:
if self.__browser.page().hasValidSslInfo():
backgroundColor = Preferences.getHelp(
"SaveUrlColor")
else:
backgroundColor = Preferences.getHelp("SaveUrlColor")
highlight = QApplication.palette().color(QPalette.Highlight)
r = (highlight.red() + 2 * backgroundColor.red()) // 3
g = (highlight.green() + 2 * backgroundColor.green()) // 3
b = (highlight.blue() + 2 * backgroundColor.blue()) // 3
loadingColor = QColor(r, g, b)
if abs(loadingColor.lightness() -
backgroundColor.lightness()) < 20:
# special handling for special color schemes (e.g Gaia)
r = (2 * highlight.red() + backgroundColor.red()) // 3
g = (2 * highlight.green() + backgroundColor.green()) // 3
b = (2 * highlight.blue() + backgroundColor.blue()) // 3
loadingColor = QColor(r, g, b)
gradient = QLinearGradient(QPointF(0, 0),
QPointF(self.width(), 0))
gradient.setColorAt(0, loadingColor)
gradient.setColorAt(progress / 100.0 - 0.000001, loadingColor)
gradient.setColorAt(progress / 100.0, backgroundColor)
p.setBrush(QPalette.Base, gradient)
self.setPalette(p)
E5LineEdit.paintEvent(self, evt)
def sum_pixels(pixel1, pixel2):
pixel1_rgb = QColor(pixel1)
pixel2_rgb = QColor(pixel2)
new_rgb = [
pixel1_rgb.red() + pixel2_rgb.red(),
pixel1_rgb.green() + pixel2_rgb.green(),
pixel1_rgb.blue() + pixel2_rgb.blue()
]
red, green, blue = ColorHelper.limit_color(new_rgb)
return qRgb(red, green, blue)
def set_colors(data: bin,
fg: QColor,
bg: QColor,
trans: QColor,
swap_fg_bg=False) -> bin: # pylint: disable=too-many-locals
"""
Burns foreground and background colors into a raster image, and returns
the results as a PNG binary
"""
image = QImage()
image.loadFromData(data)
if image.isNull():
raise UnreadablePictureException(
'Could not read embedded picture data')
image = image.convertToFormat(QImage.Format_ARGB32)
ucharptr = image.bits()
ucharptr.setsize(image.byteCount() * image.height())
fg_rgba = qRgba(fg.red(), fg.green(), fg.blue(),
fg.alpha()) if fg and fg.isValid() else None
bg_rgba = qRgba(bg.red(), bg.green(), bg.blue(),
bg.alpha()) if bg and bg.isValid() else None
COLOR_TOLERANCE = 40
fg_comp = 0
bg_comp = 255
for y in range(image.height()):
start = y * image.width() * 4
for x in range(image.width()):
x_start = x * 4 + start
rgba = struct.unpack('I', ucharptr[x_start:x_start + 4])[0]
if trans and abs(qRed(rgba) - trans.red(
)) < COLOR_TOLERANCE and abs(qGreen(rgba) - trans.green(
)) < COLOR_TOLERANCE and abs(qBlue(rgba) -
trans.blue()) < COLOR_TOLERANCE:
ucharptr[x_start:x_start + 4] = struct.pack(
'I', qRgba(0, 0, 0, 0))
elif fg_rgba is not None and abs(
qRed(rgba) - fg_comp) < COLOR_TOLERANCE and abs(
qGreen(rgba) - fg_comp) < COLOR_TOLERANCE and abs(
qBlue(rgba) - fg_comp) < COLOR_TOLERANCE:
ucharptr[x_start:x_start + 4] = struct.pack('I', fg_rgba)
elif bg_rgba is not None and abs(
qRed(rgba) - bg_comp) < COLOR_TOLERANCE and abs(
qGreen(rgba) - bg_comp) < COLOR_TOLERANCE and abs(
qBlue(rgba) - bg_comp) < COLOR_TOLERANCE:
ucharptr[x_start:x_start + 4] = struct.pack('I', bg_rgba)
# convert to PNG
png_data = QBuffer()
image.save(png_data, "png")
return png_data.data()
def QColorLerp(a: QColor, b: QColor, t: float):
"""
Blends two QColors. t=0 returns a. t=1 returns b. t=0.5 returns evenly mixed.
"""
t = max(min(t, 1.0), 0.0)
i_t = 1.0 - t
return QColor(
int((a.red() * i_t) + (b.red() * t)),
int((a.green() * i_t) + (b.green() * t)),
int((a.blue() * i_t) + (b.blue() * t)),
int((a.alpha() * i_t) + (b.alpha() * t)),
)
def mixColors(col1, col2, f=.5):
fromString = False
if type(col1) == str:
fromString = True
col1 = QColor(col1)
if type(col2) == str:
col2 = QColor(col2)
f2 = 1 - f
r = col1.red() * f + col2.red() * f2
g = col1.green() * f + col2.green() * f2
b = col1.blue() * f + col2.blue() * f2
return QColor(r, g, b) if not fromString else QColor(r, g, b).name()
def overlay_colors(bottom: QColor, top: QColor) -> QColor:
bottom_multiplier = (1 - (top.alpha() / 255)) * (bottom.alpha() / 255)
top_multiplier = top.alpha() / 255
alpha_multiplier = bottom_multiplier + top_multiplier
return QColor(
(bottom.red() * bottom_multiplier + top.red() * top_multiplier) /
alpha_multiplier,
(bottom.green() * bottom_multiplier + top.green() * top_multiplier) /
alpha_multiplier,
(bottom.blue() * bottom_multiplier + top.blue() * top_multiplier) /
alpha_multiplier,
alpha_multiplier * 255,
)
def __invert_color(self, ColourToInvert: QtGui.QColor) -> QtGui.QColor:
RGBMAX = 255
R = RGBMAX - ColourToInvert.red()
G = RGBMAX - ColourToInvert.green()
B = RGBMAX - ColourToInvert.blue()
if ColourToInvert.red() + 50 > R > ColourToInvert.red() - 50:
R = 255
if ColourToInvert.green() + 50 > G > ColourToInvert.green() - 50:
G = 255
if ColourToInvert.blue() + 50 > B > ColourToInvert.blue() - 50:
B = 255
return QtGui.QColor.fromRgb(R, G, B)
def mixColors(col1, col2, f=.5):
fromString = False
if type(col1) == str:
fromString = True
col1 = QColor(col1)
if type(col2) == str:
col2 = QColor(col2)
f2 = 1-f
r = col1.red() * f + col2.red() * f2
g = col1.green() * f + col2.green() * f2
b = col1.blue() * f + col2.blue() * f2
return QColor(r, g, b) if not fromString else QColor(r, g, b).name()
def createHeader(self):
self.gridHeader = QGroupBox("Maschine 1: Status")
layout = QGridLayout()
##### Label Status #####
labelStatus = QLabel()
labelStatusFont = QFont("CorpoS", 20, QFont.Normal)
labelStatus.setText("Produkt in Arbeit ...")
labelStatus.setFont(labelStatusFont)
labelStatus.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
labelStatus.setAutoFillBackground(True)
greenColor = QColor(0, 255, 0)
yellowColor = QColor(255, 255, 0)
redColor = QColor(255, 0, 0)
alpha = 150
values = "{r}, {g}, {b}, {a}".format(r=yellowColor.red(),
g=yellowColor.green(),
b=yellowColor.blue(),
a=alpha)
labelStatus.setStyleSheet("QLabel { background-color: rgba(" + values +
"); }")
layout.addWidget(labelStatus, 0, 0)
##### Label Countdown #####
labelCountdown = QLabel()
labelCountdownFont = QFont("CorpoS", 20, QFont.Bold)
labelCountdown.setText("12 sec")
labelCountdown.setFont(labelCountdownFont)
labelCountdown.setAlignment(Qt.AlignCenter | Qt.AlignRight)
layout.addWidget(labelCountdown, 0, 1)
layout.setColumnStretch(0, 20)
layout.setColumnStretch(1, 10)
self.gridHeader.setLayout(layout)
class ColorButton(QPushButton):
colorChanged = pyqtSignal(QColor)
def __init__(self, parent=None, color: Optional[QColor] = None):
super().__init__(parent)
self.setFixedWidth(35)
self.clicked.connect(self.click)
self.color = QColor(0, 0, 0, 255) if color is None else color
@property
def color(self):
return QColor(self._color)
@color.setter
def color(self, color: QColor):
self._color = QColor(color)
self._updateUI()
def _updateUI(self):
self.setStyleSheet(
"QPushButton {{ background-color: rgba({}, {}, {}, {}) }}".format(
self._color.red(), self._color.green(), self._color.blue(),
self._color.alpha()))
@pyqtSlot()
def click(self):
col = QColorDialog.getColor(self._color, self, "",
QColorDialog.ShowAlphaChannel)
if col.isValid():
self.color = col
self.colorChanged.emit(self._color)
def convert(self):
colors_matrix = []
img = self.image
output = QImage(img.width(), img.height(), img.format())
# get the grey value
for w in range(img.width()):
temp = []
for h in range(img.height()):
value = QColor(img.pixel(w, h))
grey = value.red() * 0.299 + value.green() * 0.587 + value.blue() * 0.144
grey = grey * pow(-1, w + h)
temp.append(grey)
colors_matrix.append(temp)
# run method here
result_matrix = DFT(colors_matrix)
# return the answer
for w in range(output.width()):
for h in range(output.height()):
grey = result_matrix[w][h] if result_matrix[w][h] <= 255 else 255
output.setPixelColor(w, h, QColor(grey, grey, grey, 255))
result_pixmap = QPixmap().fromImage(output)
self.label2.setPixmap(result_pixmap)
def _paint_tooltip(self, painter: QPainter, point: QPoint, y: int, x: int,
plot_name: str, color: QColor,
vertical_offset: int) -> int:
painter.setPen(QPen(QColor(40, 40, 40)))
res = self._tooltip_func(y, x, plot_name)
painter.setBrush(self._default_tooltip_brush)
point = QPoint(point.x() + self._tooltip_horizontal_offset,
point.y() + vertical_offset)
color = QColor(min(color.red() * 1.4, 255),
min(color.green() * 1.4, 255),
min(color.blue() * 1.4, 255), 200)
if res is not None:
lines: List = res.split('\n')
lengths = [len(l) for l in lines]
fm = QFontMetrics(self.font)
width = fm.width(lines[lengths.index(max(lengths))])
height = fm.height() * len(lines)
path = QPainterPath()
path.addRoundedRect(
QRectF(QPointF(point.x() - 5,
point.y() - 5), QSizeF(width + 10,
height + 10)), 10., 10.)
painter.fillPath(path, color)
painter.drawPath(path)
painter.drawText(QRect(point, QSize(width, height)),
xor(Qt.AlignLeft, Qt.AlignTop), res)
return height + 11
return 0
def draw_unit(x: int, y: int, c: QtGui.QColor, _draw: DRAW):
# 计算单元方块对应的屏幕坐标
left = x * UNIT
top = (HEIGHT - y - 1) * UNIT
right = (x + 1) * UNIT - 1
bottom = (HEIGHT - y) * UNIT - 1
# 画单元方块
if _draw is DRAW.SHOW:
# 画普通方块
set_color(0x006060)
rounded_rect(left + 1, top + 1, right - 1, bottom - 1, 5, 5)
set_color(0x003030)
rounded_rect(left, top, right, bottom, 8, 8)
set_fill_color(c)
set_color(Color.LIGHT_GRAY)
draw_rect(left + 2, top + 2, right - 2, bottom - 2)
elif _draw is DRAW.FIX:
# 画固定的方块
c = QtGui.QColor(c)
set_fill_color(
rgb(c.red() * 2 // 3,
c.green() * 2 // 3,
c.blue() * 2 // 3))
set_color(Color.DARK_GRAY)
draw_rect(left + 1, top + 1, right - 1, bottom - 1)
elif _draw is DRAW.CLEAR:
# 擦除方块
set_fill_color(Color.BLACK)
fill_rect(x * UNIT, (HEIGHT - y - 1) * UNIT, (x + 1) * UNIT,
(HEIGHT - y) * UNIT)
def _get_flight_bgcolor(fl: XNFlight) -> QColor:
ret = QColor(255, 255, 255)
mis = fl.mission
if mis == 'ownharvest':
ret = QColor(255, 255, 200)
elif mis == 'owndeploy':
ret = QColor(200, 200, 255)
elif mis == 'ownattack':
ret = QColor(255, 200, 230)
elif mis == 'owntransport':
ret = QColor(200, 255, 200)
elif mis == 'ownespionage':
ret = QColor(255, 220, 150)
elif mis == 'owncolony':
ret = QColor(190, 210, 255)
elif mis == 'ownmissile':
ret = QColor(165, 255, 255)
elif mis == 'ownbase':
ret = QColor(153, 200, 255)
elif mis == 'attack':
ret = QColor(255, 230, 230)
if fl.direction == 'return':
# darken -20%
ret.setRed(ret.red() * 0.8)
ret.setGreen(ret.green() * 0.8)
ret.setBlue(ret.blue() * 0.8)
return ret
class EMColorModel:
"""
Contains an array of colors used for painting the bg and FG of tiles.
This class will be added to EMModel.py in the future, and updated to
match the existing model classes.
"""
def __init__(self, name, r, g, b):
self.name = name
self.color = QColor(r, g, b)
def setColor(self, r, g, b):
self.color = QColor(r, g, b)
def setName(self, name):
self.name = name
def getName(self):
return self.name
def getColor(self):
return self.color
def jsonObj(self):
return {
"name": self.name,
"r": self.color.red(),
"g": self.color.green(),
"b": self.color.blue(),
}
class ColorSwatchWidget(QLabel):
def __init__(self, color=QColor(255, 255, 255, 255)):
if isinstance(color, QColor):
self.current_color = color
else:
# otherwise, it should be an rgb or rgba tuple
if len(color) == 3:
self.current_color = QColor(color[0], color[1], color[2], 255)
else:
self.current_color = QColor(color[0], color[1], color[2], color[3])
super(QLabel, self).__init__("")
self.setMinimumSize(30, 30)
self.reset_style_sheet()
def reset_style_sheet(self):
color_string = "rgb(" + str(self.current_color.red()) + ", " + \
str(self.current_color.green()) + ", " + \
str(self.current_color.blue()) + ")"
self.setStyleSheet("QLabel { background-color : "+ color_string + "; "
"border-style: outset;"
"border-width: 2px;"
"border-color: beige;}")
def set_color(self, color):
self.current_color = color
def mousePressEvent(self, e):
color_dialog = QColorDialog()
color_dialog.exec_()
self.current_color = color_dialog.selectedColor()
self.reset_style_sheet()
def value(self):
return self.current_color
def highligting(self, color, underline_width):
color = QColor(color)
color = QColor(color.red(), color.green(), color.blue(), 200)
painter = QPainter(self)
if config.hover_underline:
font_metrics = QFontMetrics(self.font())
text_width = font_metrics.width(self.word)
text_height = font_metrics.height()
brush = QBrush(color)
pen = QPen(brush, underline_width, Qt.SolidLine, Qt.RoundCap)
painter.setPen(pen)
if not self.skip:
painter.drawLine(0, text_height - underline_width, text_width,
text_height - underline_width)
if config.hover_hightlight:
x = y = 0
y += self.fontMetrics().ascent()
painter.setPen(color)
painter.drawText(
x,
y + config.outline_top_padding - config.outline_bottom_padding,
self.word)
def draw_game_object(self, game_object):
x = int(game_object.x - game_object.width / 2)
y = int(game_object.y - game_object.height / 2)
self.scene_label.close()
if game_object.tag == 'UI':
lbl = ObjectLabel(self.scene_label, game_object.name)
lbl.setAutoFillBackground(True)
lbl.move(x, y)
lbl.setText(game_object.text)
lbl.resize(game_object.width, game_object.height)
color = QColor(229, 229, 229)
alpha = 255
values = "{r}, {g}, {b}, {a}".format(r=color.red(),
g=color.green(),
b=color.blue(),
a=alpha)
lbl.setStyleSheet("QLabel { background-color: rgba(" + values +
"); }")
self.game_objects[game_object.name] = lbl
else:
lbl = ObjectLabel(self.scene_label, game_object.name)
pixmap = QPixmap(game_object.path_to_sprite)
lbl.resize(game_object.width, game_object.height)
lbl.move(x, y)
lbl.setPixmap(pixmap)
self.game_objects[game_object.name] = lbl
self.scene_label.showFullScreen()
def convertColor(value: QColor):
return (
value.red() / 255,
value.green() / 255,
value.blue() / 255,
value.alpha() / 255
)
def negate(color: QtG.QColor) -> QtG.QColor:
"""Negates the given color.
:param color: The base color.
:return: The negated color.
"""
return QtG.QColor(255 - color.red(), 255 - color.green(), 255 - color.blue())
def draw_text_n_outline(self, painter: QPainter, x, y, outline_width,
outline_blur, text):
outline_color = QColor(config.outline_color)
font = self.font()
text_path = QPainterPath()
if config.R2L_from_B:
text_path.addText(x, y, font, ' ' + r2l(text.strip()) + ' ')
else:
text_path.addText(x, y, font, text)
# draw blur
range_width = range(outline_width, outline_width + outline_blur)
# ~range_width = range(outline_width + outline_blur, outline_width, -1)
for width in range_width:
if width == min(range_width):
alpha = 200
else:
alpha = (max(range_width) - width) / max(range_width) * 200
alpha = int(alpha)
blur_color = QColor(outline_color.red(), outline_color.green(),
outline_color.blue(), alpha)
blur_brush = QBrush(blur_color, Qt.SolidPattern)
blur_pen = QPen(blur_brush, width, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin)
painter.setPen(blur_pen)
painter.drawPath(text_path)
# draw outline
outline_color = QColor(outline_color.red(), outline_color.green(),
outline_color.blue(), 255)
outline_brush = QBrush(outline_color, Qt.SolidPattern)
outline_pen = QPen(outline_brush, outline_width, Qt.SolidLine,
Qt.RoundCap, Qt.RoundJoin)
painter.setPen(outline_pen)
painter.drawPath(text_path)
# draw text
color = self.palette().color(QPalette.Text)
painter.setPen(color)
painter.drawText(x, y, text)
def __set_color(self, color: QtGui.QColor = None):
max = color.red()
if max < color.green():
max = color.green()
if max < color.blue():
max = color.blue()
max = int(100 * max / 255)
self.RGB_R_SLIDER.setValue(color.red())
self.RGB_R_SPIN.setValue(color.red())
self.RGB_G_SLIDER.setValue(color.green())
self.RGB_G_SPIN.setValue(color.green())
self.RGB_B_SLIDER.setValue(color.blue())
self.RGB_B_SPIN.setValue(color.blue())
self.RGB_HEXA_EDIT.setText(color.name())
self.preview.setStyleSheet("background-color:%s;" % color.name())
self.preview.style().unpolish(self.preview)
self.preview.style().polish(self.preview)
def ideal_text_color(self, bg_color: qtg.QColor):
"""Returns a text color that is visible on a given background color"""
threshold = 105
background_delta = (bg_color.red() * 0.299) + \
(bg_color.green() * 0.587) + (bg_color.blue() * 0.114)
if 255 - background_delta < threshold:
return "#000000"
else:
return "#ffffff"
def updateLineGradient(self):
pos_top = self.boundingRect().top()
pos_bot = self.boundingRect().bottom()
if self.item2.scenePos().y() >= self.item1.scenePos().y():
pos1 = 0
pos2 = 1
else:
pos1 = 1
pos2 = 0
port_type1 = self.item1.getPortType()
port_type2 = self.item2.getPortType()
port_gradient = QLinearGradient(0, pos_top, 0, pos_bot)
#if port_type1 == PORT_TYPE_AUDIO_JACK:
#port_gradient.setColorAt(pos1, canvas.theme.line_audio_jack_sel if self.m_lineSelected else canvas.theme.line_audio_jack)
#elif port_type1 == PORT_TYPE_MIDI_JACK:
#port_gradient.setColorAt(pos1, canvas.theme.line_midi_jack_sel if self.m_lineSelected else canvas.theme.line_midi_jack)
#elif port_type1 == PORT_TYPE_MIDI_ALSA:
#port_gradient.setColorAt(pos1, canvas.theme.line_midi_alsa_sel if self.m_lineSelected else canvas.theme.line_midi_alsa)
#elif port_type1 == PORT_TYPE_PARAMETER:
#port_gradient.setColorAt(pos1, canvas.theme.line_parameter_sel if self.m_lineSelected else canvas.theme.line_parameter)
#if port_type2 == PORT_TYPE_AUDIO_JACK:
#port_gradient.setColorAt(pos2, canvas.theme.line_audio_jack_sel if self.m_lineSelected else canvas.theme.line_audio_jack)
#elif port_type2 == PORT_TYPE_MIDI_JACK:
#port_gradient.setColorAt(pos2, canvas.theme.line_midi_jack_sel if self.m_lineSelected else canvas.theme.line_midi_jack)
#elif port_type2 == PORT_TYPE_MIDI_ALSA:
#port_gradient.setColorAt(pos2, canvas.theme.line_midi_alsa_sel if self.m_lineSelected else canvas.theme.line_midi_alsa)
#elif port_type2 == PORT_TYPE_PARAMETER:
#port_gradient.setColorAt(pos2, canvas.theme.line_parameter_sel if self.m_lineSelected else canvas.theme.line_parameter)
base_color = canvas.theme.line_audio_jack
if self.m_lineSelected:
base_color = canvas.theme.line_audio_jack_sel
if port_type1 == PORT_TYPE_MIDI_JACK:
base_color = canvas.theme.port_midi_jack_bg
if self.m_lineSelected:
base_color = canvas.theme.port_midi_jack_bg_sel
if self.m_is_semi_hidden:
base_color = QColor(
int(base_color.red() * canvas.semi_hide_opacity + 0.5),
int(base_color.green() * canvas.semi_hide_opacity + 0.5),
int(base_color.blue() * canvas.semi_hide_opacity + 0.5))
if self.m_ready_to_disc:
port_gradient.setColorAt(pos1, QColor(34, 34, 34))
port_gradient.setColorAt(pos2, QColor(34, 34, 34))
self.setPen(QPen(port_gradient, 2, Qt.DotLine))
else:
port_gradient.setColorAt(0, base_color.lighter(130))
port_gradient.setColorAt(0.5, base_color.darker(130))
port_gradient.setColorAt(1, base_color.lighter(130))
self.setPen(QPen(port_gradient, 1.750001, Qt.SolidLine, Qt.FlatCap))
class ColorMatch(QWidget, Ui_ColorMatch):
"""Main Window."""
def __init__(self):
QWidget.__init__(self)
self.setupUi(self)
self.selectedColor = None
self.colorButton.clicked.connect(self.colorButtonClicked)
self.rRangeSpinBox.valueChanged.connect(self.updateColors)
self.gRangeSpinBox.valueChanged.connect(self.updateColors)
self.bRangeSpinBox.valueChanged.connect(self.updateColors)
def colorButtonClicked(self):
try:
if self.selectedColor is not None:
self.selectedColor = QColorDialog().getColor(self.selectedColor)
else:
self.selectedColor = QColorDialog().getColor()
if self.selectedColor.isValid():
self.updateColors();
except Exception as e:
logging.exception(e)
def updateColors(self):
if self.selectedColor is not None:
rgb = [self.selectedColor.red(),self.selectedColor.green(),self.selectedColor.blue()]
self.lowerColor, self.upperColor = ColorUtils.getColorRange(rgb, self.rRangeSpinBox.value(), self.gRangeSpinBox.value(), self.bRangeSpinBox.value())
#Convert the RGB tuples to hex for CSS
hex_lower = '#%02x%02x%02x' % self.lowerColor
hex_upper = '#%02x%02x%02x' % self.upperColor
self.min_color.setStyleSheet("background-color: "+hex_lower)
self.mid_color.setStyleSheet("background-color: "+self.selectedColor.name())
self.max_color.setStyleSheet("background-color: "+hex_upper)
def getOptions(self):
options = dict()
options['color_range'] = [self.lowerColor, self.upperColor]
options['selected_color'] = (self.selectedColor.red(),self.selectedColor.green(),self.selectedColor.blue())
options['range_values']=(self.rRangeSpinBox.value(), self.gRangeSpinBox.value(), self.bRangeSpinBox.value())
return options
def validate(self):
if self.selectedColor is None:
return "Please select a search color."
return None;
def loadOptions(self, options):
if 'range_values' in options and 'selected_color' in options:
ranges = literal_eval(options['range_values'])
self.rRangeSpinBox.setValue(ranges[0])
self.gRangeSpinBox.setValue(ranges[1])
self.bRangeSpinBox.setValue(ranges[2])
selected_color = literal_eval(options['selected_color'])
self.selectedColor = QColor(selected_color[0],selected_color[1],selected_color[2])
self.updateColors()
def q_color_to_color(q_color: QColor) -> Color:
"""Create a `Color` from a `QColor`
Args:
q_color (QColor): The source `QColor`
Returns: Color
"""
return Color(q_color.red(), q_color.green(), q_color.blue(),
q_color.alpha())
def render_color_scribble(self):
r = []
g = []
b = []
for i in range(8):
for j in range(8):
color = QColor(self.scribble_widget.image().pixel(j, i))
r.append(color.red())
g.append(color.green())
b.append(color.blue())
self.set_rgb(r, g, b)
def qcolor2rgbmpl(qcolor: QColor) -> Tuple[float, float, float]:
"""
Calculates the red, green and blue components of the given QColor instance.
:param qcolor: the input QColor instance
:type qcolor: QColor
:return: the triplet of the three RGB color values
:type: a tuple of three floats
"""
red = qcolor.red() / 255.0
green = qcolor.green() / 255.0
blue = qcolor.blue() / 255.0
return red, green, blue
def hsl_changed(self, *_args):
if self.changing:
return
h, s, l = self.spin_h.value(), self.spin_s.value(), self.spin_l.value()
hsl = QColor()
hsl.setHsl(h, s, l)
r, g, b = hsl.red(), hsl.green(), hsl.blue()
self.changing = True
self.spin_r.setValue(r)
self.spin_g.setValue(g)
self.spin_b.setValue(b)
self.changing = False
self.rgb_led.set_rgb_value(r, g, b)
self.label_color.setStyleSheet('QLabel {{ background: #{:02x}{:02x}{:02x} }}'.format(r, g, b))
class ClockBack(QColorThemedGraphicsObject):
"""
Draw a nice back face of the clock.
This is just the white circle for now.
"""
def get_alpha(self):
return self._alpha
def set_alpha(self,c):
self._alpha = c
self.update()
alpha = pyqtProperty(float, get_alpha, set_alpha)
def get_line_width(self):
return self._line_width
def set_line_width(self,c):
self._line_width = c
self.update()
line_width = pyqtProperty(float, get_line_width, set_line_width)
def set_outline_color(self, outline_color):
self._outline_color = outline_color
def __init__(self, size, *args, **kw):
super(ClockBack,self).__init__(*args, **kw)
self.size = size
self.bbox = QRectF(0, 0, self.size, self.size)
self._color = QColor(255,0,0,255)
self._outline_color = QColor(255,0,0,255)
self._alpha = 255
self._line_width = 3
def paint(self, painter, option, widget):
# Draw background
painter.setPen(QPen(QColor(self._outline_color.red(),
self._outline_color.green(),
self._outline_color.blue(),
0.5*255 + 0.5*self._alpha
), self._line_width))
# How much white to mix in?
# At low alpha, I want the background to be super close to
# pure white.
A=(1 - 0.07*(self._alpha/255.))
B=1-A
painter.setBrush(QColor(255*A+B*self._color.red(),
255*A+B*self._color.green(),
255*A+B*self._color.blue(),
self._alpha
))
center = self.size/2
painter.drawEllipse(self.bbox)
## Draw four ticks along the sides
#pen = QPen(QColor(self._color.red(),
# self._color.green(),
# self._color.blue(),
# 128), 2)
#painter.setPen(pen)
#START, END = 0.40, 0.43
#painter.drawLine(QPointF(center, center + START*self.size),
# QPointF(center, center + END*self.size))
#painter.drawLine(QPointF(center, center - START*self.size),
# QPointF(center, center - END*self.size))
#painter.drawLine(QPointF(center + START*self.size, center),
# QPointF(center + END*self.size, center))
#painter.drawLine(QPointF(center - START*self.size, center),
# QPointF(center - END*self.size, center))
def boundingRect(self):
return QRectF(-self._line_width,
-self._line_width,
self.size + 2*self.line_width,
self.size + 2*self.line_width)
def mouseMoveEvent(self, event):
if not self.cross:
mouse_x = event.pos().x()
mouse_y = event.pos().y()
self.mouse_pos = event.pos()
if self.img != None:
rgb = QColor(self.img.pixel(self.mouse_pos))
text = "XY[" + str(mouse_x) + "," + str(mouse_y)+ "] RGB(" + str(rgb.red()) + "," + str(rgb.green()) + "," + str(rgb.blue()) + ")"
QToolTip.showText(QPoint(QCursor.pos()), text)
self.repaint()
class ColorItem(QGraphicsItem):
n = 0
def __init__(self):
super(ColorItem, self).__init__()
self.color = QColor(qrand() % 256, qrand() % 256, qrand() % 256)
self.setToolTip(
"QColor(%d, %d, %d)\nClick and drag this color onto the robot!"
% (self.color.red(), self.color.green(), self.color.blue())
)
self.setCursor(Qt.OpenHandCursor)
self.setAcceptedMouseButtons(Qt.LeftButton)
def boundingRect(self):
return QRectF(-15.5, -15.5, 34, 34)
def paint(self, painter, option, widget):
painter.setPen(Qt.NoPen)
painter.setBrush(Qt.darkGray)
painter.drawEllipse(-12, -12, 30, 30)
painter.setPen(QPen(Qt.black, 1))
painter.setBrush(QBrush(self.color))
painter.drawEllipse(-15, -15, 30, 30)
def mousePressEvent(self, event):
self.setCursor(Qt.ClosedHandCursor)
def mouseMoveEvent(self, event):
if (
QLineF(QPointF(event.screenPos()), QPointF(event.buttonDownScreenPos(Qt.LeftButton))).length()
< QApplication.startDragDistance()
):
return
drag = QDrag(event.widget())
mime = QMimeData()
drag.setMimeData(mime)
ColorItem.n += 1
if ColorItem.n > 2 and qrand() % 3 == 0:
root = QFileInfo(__file__).absolutePath()
image = QImage(root + "/images/head.png")
mime.setImageData(image)
drag.setPixmap(QPixmap.fromImage(image).scaled(30, 40))
drag.setHotSpot(QPoint(15, 30))
else:
mime.setColorData(self.color)
mime.setText("#%02x%02x%02x" % (self.color.red(), self.color.green(), self.color.blue()))
pixmap = QPixmap(34, 34)
pixmap.fill(Qt.white)
painter = QPainter(pixmap)
painter.translate(15, 15)
painter.setRenderHint(QPainter.Antialiasing)
self.paint(painter, None, None)
painter.end()
pixmap.setMask(pixmap.createHeuristicMask())
drag.setPixmap(pixmap)
drag.setHotSpot(QPoint(15, 20))
drag.exec_()
self.setCursor(Qt.OpenHandCursor)
def mouseReleaseEvent(self, event):
self.setCursor(Qt.OpenHandCursor)
def _update_colors(self):
op = self.topLevelOperatorView
ctable = self._doneSegmentationLayer.colorTable
for name, label in self._shownObjects3D.items():
color = QColor(ctable[op.MST.value.object_names[name]])
color = (old_div(color.red(), 255.0), old_div(color.green(), 255.0), old_div(color.blue(), 255.0))
self._renderMgr.setColor(label, color)
if self._showSegmentationIn3D and self._segmentation_3d_label is not None:
self._renderMgr.setColor(self._segmentation_3d_label, (0.0, 1.0, 0.0)) # Green
class MovablePolyLine(QGraphicsObject):
def __init__(self, parent=None):
super(MovablePolyLine, self).__init__(parent)
self.setZValue(1000)
self.polygon = QPolygonF()
self.radius = 5.0
self.itemList = []
self.rect = QRectF()
self.color = QColor(255,0,0)
self.lineWidth = 5
self.brightness = 0
self.setOpacity(0.5)
# self.setHandlesChildEvents(False)
# self.setFlags(QGraphicsItem.ItemIsMovable)
self.isDrawLine = True
self.drawItemFlags = None
self.points = None
self.itemType = QGraphicsEllipseItem
def setDrawLine(self, flag):
self.isDrawLine = flag
def setDrawItems(self, flags):
self.drawItemFlags = flags
for item, flag in zip(self.itemList, flags):
if flag:
item.show()
else:
item.hide()
def setRadius(self, r):
self.radius = r
if self.points is None:
return
radii = 2*self.radius
rectList = [QRectF(-self.radius, -self.radius, radii, radii) for p in self.points]
for item, rect in zip(self.itemList, rectList):
item.setRect(rect)
def setLineWidth(self, w):
self.lineWidth = w
self.update()
def getLineWidth(self):
return self.lineWidth
def setColor(self, rgb):
rgb = [min(val+self.brightness, 255) for val in rgb]
self.color = QColor(*rgb)
for item in self.itemList:
item.setBrush(self.color)
def setBrightness(self, val):
delta = val - self.brightness
self.brightness = val
rgb = [min(val+delta, 255) for val in [self.color.red(), self.color.green(), self.color.blue()]]
self.color = QColor(*rgb)
for item in self.itemList:
item.setBrush(self.color)
def getRadius(self):
return self.radius
# TODO:NaNが入ってると劇的に重くなるので，無理矢理NaNをはじいてはいる．
#もう少しきれいに書き直すこと．
#フレームが前に進むたびに値を詰め直しているためおそいので，その対策も同時に．
def setPoints(self, ps=None, flags=None):
if ps is not None and self.points is not None:
points = [p for p in ps if not np.any(pd.isnull(p))]
if len(points)==len(self.points):
self.points = points
for item, point in zip(self.itemList, self.points):
item.setPos(*point)
item.mouseMoveEvent = self.generateItemMouseMoveEvent(item, point)
item.mousePressEvent = self.generateItemMousePressEvent(item, point)
self.update()
return
scene = self.scene()
if scene is not None:
for item in self.itemList:
scene.removeItem(item)
del item
self.itemList.clear()
if flags is not None:
self.drawItemFlags = flags
drawItemFlags = self.drawItemFlags
if ps is not None:
self.points = [p for p in ps if not np.any(pd.isnull(p))]
drawItemFlags = [f for f, p in zip(self.drawItemFlags, ps) if not np.any(pd.isnull(p))]
if self.points is not None:
radii = 2*self.radius
rectList = [QRectF(-self.radius, -self.radius, radii, radii) for p in self.points]
self.itemList = [self.itemType(self) for rect in rectList]
for item, point, rect, flag in zip(self.itemList, self.points, rectList, drawItemFlags):
item.setBrush(self.color)
item.setRect(rect)
item.setPos(*point)
if not flag:
item.hide()
item.setFlags(QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemSendsScenePositionChanges)
item.setAcceptHoverEvents(True)
item.mouseMoveEvent = self.generateItemMouseMoveEvent(item, point)
item.mousePressEvent = self.generateItemMousePressEvent(item, point)
def setRect(self, rect):
self.rect = rect
def generateItemMouseMoveEvent(self, item, point):
def itemMouseMoveEvent(event):
self.itemType.mouseMoveEvent(item, event)
centerPos = item.scenePos()
point[0] = centerPos.x()
point[1] = centerPos.y()
self.update()
return itemMouseMoveEvent
def generateItemMousePressEvent(self, item, point):
def itemMousePressEvent(event):
self.itemType.mousePressEvent(item, event)
pass
return itemMousePressEvent
def boundingRect(self):
return self.rect
def paint(self, painter, option, widget):
if self.points is not None and self.isDrawLine:
painter.save()
pen = QPen(self.color)
pen.setWidth(self.getLineWidth())
painter.setPen(pen)
qPoints = [QPointF(*p.tolist()) for p in self.points]
polygon = QPolygonF(qPoints)
painter.drawPolyline(polygon)
painter.restore()
def updateGUI(self):
defined_img=None
if self.file_path is not None:
defined_img=QImage(self.file_path).scaled(self.IMAGE_COLS_MAX, self.IMAGE_ROWS_MAX)
img = self.camera.getOrigImage()
if defined_img is not None:
img=defined_img
self.image=img
elif defined_img is None:
if img is not None:
self.image = QImage(img.data, img.shape[1], img.shape[0], img.shape[1] * img.shape[2], QImage.Format_RGB888).scaled(self.IMAGE_COLS_MAX, self.IMAGE_ROWS_MAX)
if img is not None:
self.sourceImg.setPixmap(QPixmap.fromImage(self.image))
#Filter Image
filt = self.getFilterName()
if (filt is not "Orig"):
disc2 = self.camera.getFilter(filt).apply(self.colorSpace)
imgDisc = QImage(disc2.data, disc2.shape[1], disc2.shape[0], disc2.shape[1] * disc2.shape[2], QImage.Format_RGB888).scaled(200, 200)
self.colorSpaceLabel.setPixmap(QPixmap.fromImage(imgDisc))
img = self.camera.getOrigImage()
if defined_img is not None:
img2=cv2.imread(self.file_path)
img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)
if (filt is not "Orig"):
self.imageF=self.camera.getFilter(filt).apply(img2)
self.imageF= QImage(self.imageF.data, self.imageF.shape[1], self.imageF.shape[0], self.imageF.shape[1] * self.imageF.shape[2], QImage.Format_RGB888).scaled(self.IMAGE_COLS_MAX, self.IMAGE_ROWS_MAX)
else:
self.imageF=QImage(img2.data, img2.shape[1], img2.shape[0], img2.shape[1] * img2.shape[2], QImage.Format_RGB888).scaled(self.IMAGE_COLS_MAX, self.IMAGE_ROWS_MAX)
elif defined_img is None:
if img is not None:
img = self.camera.getFilteredImage(filt)
self.imageF = QImage(img.data, img.shape[1], img.shape[0], img.shape[1] * img.shape[2], QImage.Format_RGB888).scaled(self.IMAGE_COLS_MAX, self.IMAGE_ROWS_MAX)
#img = self.camera.getFilteredImage(filt)
self.filterImg.setPixmap(QPixmap.fromImage(self.imageF))
#print "update"
pos = self.sourceImg.getMousePos()
if pos != None:
#print pos
x_ini = (self.sourceImg.width()*self.ZOOM_X*pos.x())/self.sourceImg.width()
y_ini = (self.sourceImg.height()*self.ZOOM_X*pos.y())/self.sourceImg.height()
rect = QRect(x_ini-100,y_ini-100,200,200)
#print 'orig', pos.x(), ",", pos.y(), ",", self.sourceImg.size()
#print 'scale', x_ini, ",", y_ini
#self.crop.setPixmap(QPixmap.fromImage(self.image.copy(rect).scaled(1000,1000)))
#print self.sourceImg.pixmap().size()
im2 = self.image.copy().scaled(self.sourceImg.width()*self.ZOOM_X,self.sourceImg.height()*self.ZOOM_X)
self.crop.setPixmap(QPixmap.fromImage(im2.copy(rect)))
#print self.crop.pixmap().size()
pos = self.sourceImg.getMousePos()
#print pos
rgb = QColor(self.image.pixel(pos))
self.tootippixel.setStyleSheet("background: rgb(" + str(rgb.red()) + "," + str(rgb.green()) + "," + str(rgb.blue()) + "); border: 1px solid;")
self.tootippixel.setGeometry(pos.x(), pos.y()+52, 20,20)
self.pixel.setStyleSheet("background: rgb(" + str(rgb.red()) + "," + str(rgb.green()) + "," + str(rgb.blue()) + ");border: 1px solid;")
text = "XY ["+str(pos.x())+","+str(pos.y())+"]\nrgb(" + str(rgb.red()) + "," + str(rgb.green()) + "," + str(rgb.blue()) + ")"
self.rgbVal.setText(text)
class MovablePolyLine(QGraphicsObject):
def __init__(self, parent=None):
super(MovablePolyLine, self).__init__(parent)
self.setZValue(1000)
self.polygon = QPolygonF()
self.radius = 5.0
self.itemList = []
self.rect = QRectF()
self.color = QColor(255,0,0)
self.setOpacity(0.5)
# self.setHandlesChildEvents(False)
# self.setFlags(QGraphicsItem.ItemIsMovable)
self.isDrawLine = True
self.drawItemFlags = None
self.points = None
self.itemType = QGraphicsEllipseItem
def setDrawLine(self, flag):
self.isDrawLine = flag
def setDrawItems(self, flags):
self.drawItemFlags = flags
for item, flag in zip(self.itemList, flags):
if flag:
item.show()
else:
item.hide()
def setRadius(self, r):
self.radius = r
radii = 2*self.radius
rectList = [QRectF(-self.radius, -self.radius, radii, radii) for p in self.points]
for item, rect in zip(self.itemList, rectList):
item.setRect(rect)
def setLineWidth(self, w):
self.lineWidth = w
self.update()
def getLineWidth(self):
return self.lineWidth
def setColor(self, rgb):
self.color = QColor(*rgb)
for item in self.itemList:
item.setBrush(self.color)
def getColor(self):
return [self.color.red(),self.color.green(),self.color.blue()]
def getRadius(self):
return self.radius
def setPoints(self, ps=None, flags=None):
if ps is not None and self.points is not None:
if len(ps)==len(self.points):
self.points = ps
for item, point in zip(self.itemList, self.points):
item.setPos(*point)
item.mouseMoveEvent = self.generateItemMouseMoveEvent(item, point)
item.mousePressEvent = self.generateItemMousePressEvent(item, point)
self.update()
return
scene = self.scene()
if scene is not None:
for item in self.itemList:
scene.removeItem(item)
del item
self.itemList.clear()
if ps is not None:
self.points = ps
if flags is not None:
self.drawItemFlags = flags
if self.points is not None:
radii = 2*self.radius
rectList = [QRectF(-self.radius, -self.radius, radii, radii) for p in self.points]
self.itemList = [self.itemType(self) for rect in rectList]
for item, point, rect, flag in zip(self.itemList, self.points, rectList, self.drawItemFlags):
item.setBrush(self.color)
item.setRect(rect)
item.setPos(*point)
if not flag:
item.hide()
item.setFlags(QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemSendsScenePositionChanges)
item.setAcceptHoverEvents(True)
item.mouseMoveEvent = self.generateItemMouseMoveEvent(item, point)
item.mousePressEvent = self.generateItemMousePressEvent(item, point)
def setRect(self, rect):
self.rect = rect
def generateItemMouseMoveEvent(self, item, point):
def itemMouseMoveEvent(event):
self.itemType.mouseMoveEvent(item, event)
centerPos = item.scenePos()
point[0] = centerPos.x()
point[1] = centerPos.y()
self.update()
return itemMouseMoveEvent
def generateItemMousePressEvent(self, item, point):
def itemMousePressEvent(event):
self.itemType.mousePressEvent(item, event)
pass
return itemMousePressEvent
def boundingRect(self):
return self.rect
def paint(self, painter, option, widget):
if self.points is not None and self.isDrawLine:
painter.save()
pen = QPen(self.color)
pen.setWidth(self.getLineWidth())
painter.setPen(pen)
qPoints = [QPointF(*p.tolist()) for p in self.points]
polygon = QPolygonF(qPoints)
painter.drawPolyline(polygon)
painter.restore()
def updateGUI(self):
img = self.camera.getOrigImage()
if img is not None:
self.image = QImage(img.data, img.shape[1], img.shape[0], img.shape[1] * img.shape[2], QImage.Format_RGB888).scaled(self.IMAGE_COLS_MAX, self.IMAGE_ROWS_MAX)
self.sourceImg.setPixmap(QPixmap.fromImage(self.image))
filt = self.getFilterName()
img = self.camera.getFilteredImage(filt)
if img is not None:
self.imageF = QImage(img.data, img.shape[1], img.shape[0], img.shape[1] * img.shape[2], QImage.Format_RGB888).scaled(self.IMAGE_COLS_MAX, self.IMAGE_ROWS_MAX)
self.filterImg.setPixmap(QPixmap.fromImage(self.imageF))
#print "update"
pos = self.sourceImg.getMousePos()
if pos != None:
#print pos
x_ini = (self.sourceImg.width()*self.ZOOM_X*pos.x())/self.sourceImg.width()
y_ini = (self.sourceImg.height()*self.ZOOM_X*pos.y())/self.sourceImg.height()
rect = QRect(x_ini-100,y_ini-100,200,200)
#print 'orig', pos.x(), ",", pos.y(), ",", self.sourceImg.size()
#print 'scale', x_ini, ",", y_ini
#self.crop.setPixmap(QPixmap.fromImage(self.image.copy(rect).scaled(1000,1000)))
#print self.sourceImg.pixmap().size()
im2 = self.image.copy().scaled(self.sourceImg.width()*self.ZOOM_X,self.sourceImg.height()*self.ZOOM_X)
self.crop.setPixmap(QPixmap.fromImage(im2.copy(rect)))
#print self.crop.pixmap().size()
pos = self.sourceImg.getMousePos()
#print pos
rgb = QColor(self.image.pixel(pos))
self.tootippixel.setStyleSheet("background: rgb(" + str(rgb.red()) + "," + str(rgb.green()) + "," + str(rgb.blue()) + "); border: 1px solid;")
self.tootippixel.setGeometry(pos.x(), pos.y()+52, 20,20)
self.pixel.setStyleSheet("background: rgb(" + str(rgb.red()) + "," + str(rgb.green()) + "," + str(rgb.blue()) + ");border: 1px solid;")
text = "XY ["+str(pos.x())+","+str(pos.y())+"]\nrgb(" + str(rgb.red()) + "," + str(rgb.green()) + "," + str(rgb.blue()) + ")"
self.rgbVal.setText(text)
