def updateHSVPreview(self):
# Parameter : h, s, v
# h dari nilai hue yang dipilih, s dan v set ke max value (255)
prevH = generateSolidColorPixmap(
200, 300, QColor.fromHsv(self.selectedHue, 255, 255))
self.previewH.setPixmap(QPixmap.fromImage(prevH))
# h dari nilai hue yang dipilih, s dari nilai saturation yang dipilih
# v set ke max value (255)
prevS = generateSolidColorPixmap(
200, 300, QColor.fromHsv(self.selectedHue, self.selectedSaturation, 255))
self.previewS.setPixmap(QPixmap.fromImage(prevS))
# h dari nilai hue yang dipilih, s dari nilai saturation yang dipilih
# v dari nilai v yang dipilih
prevV = generateSolidColorPixmap(
200, 300, QColor.fromHsv(self.selectedHue, self.selectedSaturation, self.selectedValue))
self.previewV.setPixmap(QPixmap.fromImage(prevV))
# Check dropdown pilihan mode UPPER atau LOWER
if self.cboxSetMode.currentText() == "UPPER":
self.upperHSV = (self.selectedHue // 2,
self.selectedSaturation, self.selectedValue)
self.lblUpper.setText(
f"H {self.upperHSV[0]}; S {self.upperHSV[1]}; V {self.upperHSV[2]}")
elif self.cboxSetMode.currentText() == "LOWER":
self.lowerHSV = (self.selectedHue // 2,
self.selectedSaturation, self.selectedValue)
self.lblLower.setText(
f"H {self.lowerHSV[0]}; S {self.lowerHSV[1]}; V {self.lowerHSV[2]}")
self.updateMask()
self.updatePreviewHsvSpace()
def updateHSVPreview(self):
prevH = generateSolidColorPixmap(
200, 300, QColor.fromHsv(self.selectedHue, 255, 255))
self.previewH.setPixmap(QPixmap.fromImage(prevH))
prevS = generateSolidColorPixmap(
200, 300, QColor.fromHsv(self.selectedHue, self.selectedSaturation, 255))
self.previewS.setPixmap(QPixmap.fromImage(prevS))
prevV = generateSolidColorPixmap(
200, 300, QColor.fromHsv(self.selectedHue, self.selectedSaturation, self.selectedValue))
self.previewV.setPixmap(QPixmap.fromImage(prevV))
if self.cboxSetMode.currentText() == "UPPER":
self.upperHSV = (self.selectedHue // 2,
self.selectedSaturation, self.selectedValue)
self.lblUpper.setText(
f"H {self.upperHSV[0]}; S {self.upperHSV[1]}; V {self.upperHSV[2]}")
elif self.cboxSetMode.currentText() == "LOWER":
self.lowerHSV = (self.selectedHue // 2,
self.selectedSaturation, self.selectedValue)
self.lblLower.setText(
f"H {self.lowerHSV[0]}; S {self.lowerHSV[1]}; V {self.lowerHSV[2]}")
self.updateMask()
self.updatePreviewHsvSpace()
def percent_color(value):
zero = QColor.fromHsv(111, 100, 190)
one = QColor.fromHsv(5, 100, 190)
if value <= 0:
return zero
if value >= 1:
return one
return QColor((1 - value) * zero.red() + value * one.red(),
(1 - value) * zero.green() + value * one.green(),
(1 - value) * zero.blue() + value * one.blue())
def _getSatResult(sat, bright) -> _SaturationResult:
color_good = QColor.fromHsv(0, 0, 255) # White
color_bad = QColor.fromHsv(0, 0, 0) # Black
colorAtPosition: QColor = PROXIMITY_MAP.pixelColor(sat, bright)
brightness = colorAtPosition.getHsvF()[
2] # Return 0.0, 0.5, 1.0 to represent bad, ok, good respectively
isLow = _isInLowZone(sat, bright) # Left or right of the curve
if brightness < 0.2 and isLow: return _SaturationResult.low_limit_2
if brightness < 0.8 and isLow: return _SaturationResult.low_limit_1
if brightness < 0.2 and not isLow: return _SaturationResult.high_limit_2
if brightness < 0.8 and not isLow: return _SaturationResult.high_limit_1
return _SaturationResult.good
def drawMandelbrot(self, qp):
size = self.size()
if pointsReady is True:
numCols = size.width()
numRows = size.height()
colorIndex = 0
for row in range(0, numRows):
for col in range(0, numCols):
color = mymodule.arr[colorIndex]
colorIndex += 1
#The calculateMandelbrot will set color to -1 if the iterations are infinite else set the color based on iterations
if color != -1:
qp.setPen(QColor.fromHsv(color, 255, 255))
else:
qp.setPen(Qt.black)
#draw the point on the canvas
qp.drawPoint(col, row)
else:
#qp.setPen(Qt.gray)
qp.fillRect(0, 0, size.width(), size.height(), Qt.gray)
def accent_from_hue(self, hue):
h2 = hue * hue
h3 = h2 * hue
# polynomial approximation of how saturation and value are related to hue in Solarized
saturation = 0.0000132 * h3 - 0.0068 * h2 + 0.7769 * hue + 77.188
value = -7.07E-6 * h3 + 0.0042 * h2 - 0.6383 * hue + 88.615
return QColor.fromHsv(hue, min(255, saturation * 2.55), min(255, value * 2.55))
def build_matiere_groupe():
groups = []
for g in MATIERE_GROUPE_BASE:
cop = {k: v for k, v in g.items()} # if k != "bgColor"}
cop["bgColor"] = QColor.fromHsv(*cop["bgColor"])
groups.append(cop)
return groups
def mapper(value):
if value < lower:
hue = lowerHue
elif value > upper:
hue = upperHue
else:
hue = ((value - lower) / diff) * diffHue + lowerHue
return QColor.fromHsv(hue, 100, 255)
def paintPolygones(self, p: QPainter, x0, y0, r):
n = 200
for i in range(n):
radius = r / (n + 250) * (i + 200)
ang = 2 * pi / 100 * i
x = x0 + cos(ang) * radius
y = y0 + sin(ang) * radius
color = QColor.fromHsv(i % 360, 255, 255)
self.paintOnePolygon(p, x, y, -i / 50, color)
def getColor(key: CfgKey):
propertiesService = PropertiesService()
propertiesValue = propertiesService.find(key)
if propertiesValue == None:
colorCfgValue = cfgValue[key]
else:
colorCfgValue = propertiesValue
colorCfgValueHsvParts = colorCfgValue.split(";")
if len(colorCfgValueHsvParts) != 3:
print("Die Properties mit dem Key '" + key._name_ +
"' hat das falsche Format!")
return QColor.fromHsv(0, 0, 0)
else:
return QColor.fromHsv(int(colorCfgValueHsvParts[0]),
int(colorCfgValueHsvParts[1]),
int(colorCfgValueHsvParts[2]))
def apply_gamma_correction(image, gamma=0.5):
copy = image.copy()
for x in range(image.width()):
for y in range(image.height()):
color = image.pixelColor(x, y)
h, s, v = color.hue(), color.saturation(), color.value()
value = pow(v, gamma) * (255 / pow(255, gamma))
copy.setPixelColor(x, y, QColor.fromHsv(h, s, value))
return copy
def get_color_by_group(groupe):
matieres = {x["nom"]: x for x in MATIERES_BASE if x["groupe"] == groupe["id"]}
bgColor = QColor.fromHsv(*groupe["bgColor"])
ajout = (255 - bgColor.saturation()) / len(matieres)
for v in matieres.values():
v["bgColor"] = bgColor.toHsv()
bgColor.setHsv(
bgColor.hue(), bgColor.saturation() + round(ajout), bgColor.value()
)
return matieres
def color_for_tag(self, tag_name):
assert isinstance(tag_name, str), 'tag_name must be an str'
_counter = self._counter
if _counter.get(tag_name, 0) > 1:
# Это был бы лучший путь
h = self._tags.index(tag_name)
h = 10 * h
return QColor.fromHsv(h, 70, 70)
#Или этот:
#return QColor.fromHsl(h, 39, 51)
# c.setRgb(h, 28, 34)
else:
return self._white
def hsvUpdated(self):
qclr = QColor.fromHsv(self.hSlider.value(), self.sSlider.value(),
self.vSlider.value())
self.currentSelectedColor = qclr
self.rBox.setValue(qclr.red())
self.rSlider.setValue(qclr.red())
self.gBox.setValue(qclr.green())
self.gSlider.setValue(qclr.green())
self.bBox.setValue(qclr.blue())
self.bSlider.setValue(qclr.blue())
self.setCurrentColor()
def colorClusters(self, points):
step = 400 / len(points) - 1
for i in range(0, 400, int(step)):
color = QColor.fromHsv(i, 255, 255)
self.colors.append(color)
for i, c in enumerate(points):
for element in c:
for item in self.points_canvas.scene.items():
if isinstance(item, EntityPoint.EntityPoint):
if element.id == item.id:
item.status = "normal"
item.setBrush(self.colors[i])
def paintEvent(self,e):
painter = QPainter(self)
#painter.setRenderHint(QPainter.Antialiasing, True)
#painter.setPen(QPen(self.color, 6, Qt.SolidLine))
#painter.setBrush(QBrush(Qt.green, Qt.SolidPattern))
self.i+=1
#print(self.i)
for a in self.demet:
c, self.x0,self.y0,self.x1,self.y1=a
a0,a1,a2,a3=c
color=QColor.fromHsv(a0,a1,a2,a3)
painter.setPen(QPen(color, 5, Qt.SolidLine))
painter.drawLine(self.x0,self.y0,self.x1,self.y1) #20, 40, 250, 40
def paintEvent(self, e):
painter = QPainter(self)
#painter.setRenderHint(QPainter.Antialiasing, True)
#painter.setPen(QPen(self.color, 6, Qt.SolidLine))
#painter.setBrush(QBrush(Qt.green, Qt.SolidPattern))
self.i += 1
#print(self.i)
for a in self.demet:
c, self.x0, self.y0, self.x1, self.y1 = a
a0, a1, a2, a3 = c
color = QColor.fromHsv(a0, a1, a2, a3)
painter.setPen(QPen(color, 5, Qt.SolidLine))
painter.drawLine(self.x0, self.y0, self.x1,
self.y1) #20, 40, 250, 40
def _update_sliders(self, update_alpha_value=None):
color = (self._primarySelectedColor
if self._activeColorIndex == ColorIndex.Primary
else self._secondarySelectedColor)
# HUE
self._hueSlider.value = color.hue()
# SATURATION
self._satSlider.start_color = QColor.fromHsv(color.hue(), 0, color.value())
self._satSlider.end_color = QColor.fromHsv(color.hue(), 255, color.value())
self._satSlider.value = color.saturation()
# VALUE
self._valSlider.end_color = QColor.fromHsv(color.hue(), color.saturation(), 255)
self._valSlider.value = color.value()
# RGB
self._redSlider.value = color.red()
self._greenSlider.value = color.green()
self._blueSlider.value = color.blue()
# ALPHA
alpha_color = QColor(color)
alpha_color.setAlpha(0)
self._alphaSlider.start_color = alpha_color
alpha_color.setAlpha(255)
self._alphaSlider.end_color = alpha_color
if update_alpha_value:
self._alphaSlider.value = color.alpha()
def generate_colors(n, seed=None):
"""Generate list of `n` colors"""
colors = []
if seed is None:
h = random.random()
else:
h = seed
golden_ratio = 0.618033988749895 # 1/phi
for i in range(n):
colors.append(QColor.fromHsv(h * 360, 150, 254, 255))
h += golden_ratio
h %= 1
return colors
def paintEvent(self, evt): """Visualise update rects.""" super().paintEvent(evt) p = QPainter(self) p.setClipRegion(evt.region()) p.fillRect( 0,0, 10000,10000, QColor.fromHsv( randrange(0,360), randrange(200,256), randrange(200,256), 100 ) )
def _calculate_colors(self):
for i in range(0, 16):
self._hueArray[i] = abs((self._hue - self._hueShift * (i - 8)) % 360)
shift = (8 - abs(i - 7)) * self._baseSat / 8
new_sat = self._satArray[i] + shift
new_val = self._valArray[i] + shift
new_sat = max(0, min(255, new_sat))
new_val = max(0, min(255, new_val))
self._colArray[i] = (QColor.fromHsv(self._hueArray[i], new_sat, new_val))
first_color = self._colArray[15]
last_color = self._colArray[0]
first_color.setHsv(0, 0, 0)
last_color.setHsv(0, 0, 255)
def interpolate_hsv(col1, col2, num_middle):
"""
find colours in between the two and yield QColors including original colours
expects QColors, returns QColors from col1 to col2
expects alpha to always be 255
"""
if num_middle < 0:
raise ValueError
assert col1.isValid()
assert col2.isValid()
start_h = col1.hsvHue() % 360
start_s = col1.hsvSaturation() % 256
start_v = col1.value() % 256
delta_h = (col2.hsvHue() % 360) - start_h
# https://stackoverflow.com/questions/2593832/
# how-to-interpolate-hue-values-in-hsv-colour-space
# Can be + or -, and magnitude can be > 180 or < 180
if delta_h < -180:
# Between -360 and -180
# eg 10 - 300 = -290
# we should go the other way around
# eg 70
delta_h = 360 + delta_h
elif delta_h > 180:
# delta h between 180 and 360, we should go the other way around
delta_h = -360 + delta_h
delta_s = (col2.hsvSaturation() % 256) - start_s
delta_v = (col2.value() % 256) - start_v
yield col1
for i in range(1, num_middle + 1):
frac = i / num_middle
yield QColor.fromHsv(
(start_h + delta_h * frac) % 360,
(start_s + delta_s * frac) % 256,
(start_v + delta_v * frac) % 256,
)
yield col2
def on_color_changed(self):
""" Called when the selection color has changed. Replace every icon """
color = self.iface.mapCanvas().selectionColor()
color = QColor.fromHsv(color.hue(),
color.saturation() * 0.9,
color.value() * 0.95, color.alpha())
for i in range(len(self.select_actions)):
path = self.actions_settings[i].icon
icon = create_icon(path, color)
self.select_actions[i].setIcon(icon)
icon = create_icon(":/plugins/multilayerselect/icons/deselectAll.svg",
color)
self.deselect_all_action.setIcon(icon)
icon = select_all_icon(color)
self.select_all_action.setIcon(icon)
icon = invert_selection_icon(color)
self.invert_all_action.setIcon(icon)
icon = expression_select_icon(color)
self.select_by_expr_action.setIcon(icon)
def updateColor(self, color):
"""Sets the top right color of the panel."""
color = QColor(color)
color.setAlpha(255)
self._color = color
self._image = QImage(self.size(), QImage.Format_ARGB32)
painter = SmoothPainter(self._image)
# Render top right corner
# Choose brightest, most saturated color for the given hue. Undefined hues (greys) should default to red hue.
h = max(0, color.hsvHue())
color_full = QColor.fromHsv(h, 255, 255)
painter.fillRect(self.rect(), color_full)
# Create vertical shading
gradient = QLinearGradient(0, 0, self.width(), 0)
gradient.setColorAt(0, Qt.white)
gradient.setColorAt(1, QColor.fromHslF(0.055, 0.42, 0.65, 0))
painter.fillRect(self.rect(), gradient)
# Create horizontal shading
gradient = QLinearGradient(0, self.height(), 0, 0)
gradient.setColorAt(1, QColor.fromHslF(0.055, 0.42, 0.65, 0))
gradient.setColorAt(0, Qt.black)
painter.fillRect(self.rect(), gradient)
self._createSkinToneIndicator(painter)
painter.end()
w, h = self.width(), self.height()
_, s, v, _ = color.getHsvF()
x, y = s * w, (1 - v) * h
self._pointerPos = QPoint(x, y)
self.update()
def initialItemColor(self):
hue = ((len(self.shapeItems) + 1) * 85) % 256
return QColor.fromHsv(hue, 255, 190)
def paintEvent(self, event):
if self.fScene is None:
QFrame.paintEvent(self, event)
return
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing,
bool(options.antialiasing == ANTIALIASING_FULL))
# Brightness-aware out-of-canvas shading
bg_color = self.fViewBg
bg_black = bg_color.black()
bg_shade = -12 if bg_black < 127 else 12
r, g, b, _ = bg_color.getRgb()
bg_color = QColor(r + bg_shade, g + bg_shade, b + bg_shade)
frameWidth = self.fFrameWidth
if self.fUseCustomPaint:
# Inner shadow
color = QColor.fromHsv(40, 0,
255 - max(210, bg_color.black(), bg_black))
painter.setBrush(Qt.transparent)
painter.setPen(color)
painter.drawRect(
QRectF(0.5, 0.5,
self.width() - 1,
self.height() - 1))
# Background
painter.setBrush(bg_color)
painter.setPen(bg_color)
painter.drawRect(
QRectF(1.5, 1.5,
self.width() - 3,
self.height() - 3))
else:
use_rounding = int(frameWidth > 1)
rounding = 0.5 * use_rounding
painter.setBrush(bg_color)
painter.setPen(bg_color)
painter.drawRoundedRect(
QRectF(0.5 + frameWidth, 0.5 + frameWidth,
self.width() - 1 - frameWidth * 2,
self.height() - 1 - frameWidth * 2), rounding, rounding)
clipPath = QPainterPath()
rounding = 1.0 * use_rounding
clipPath.addRoundedRect(
QRectF(frameWidth, frameWidth,
self.width() - frameWidth * 2,
self.height() - frameWidth * 2), rounding, rounding)
painter.setClipPath(clipPath)
self.fScene.render(painter, self.fRenderTarget, self.fRenderSource,
Qt.KeepAspectRatio)
# Allow cursor frame to look joined with minicanvas frame
painter.setClipping(False)
width = self.fViewRect[self._kRectWidth] / self.fScale
height = self.fViewRect[self._kRectHeight] / self.fScale
# cursor
lineHinting = self.fViewPen.widthF() / 2
x = self.fViewRect[self._kRectX] + self.fInitialX
y = self.fViewRect[self._kRectY] + self.fInitialY
scr_x = floor(x)
scr_y = floor(y)
rect = QRectF(scr_x + lineHinting, scr_y + lineHinting,
ceil(width + x - scr_x) - lineHinting * 2,
ceil(height + y - scr_y) - lineHinting * 2)
if self.fRubberBandBlending == self._RUBBERBAND_BLENDING_PLUS:
painter.setCompositionMode(QPainter.CompositionMode_Plus)
elif self.fRubberBandBlending == self._RUBBERBAND_BLENDING_DIFF:
painter.setCompositionMode(QPainter.CompositionMode_Difference)
painter.setBrush(self.fViewBrush)
painter.setPen(Qt.NoPen)
painter.drawRect(rect)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.setBrush(Qt.NoBrush)
painter.setPen(self.fViewPen)
painter.drawRect(rect)
if self.fUseCustomPaint:
event.accept()
else:
QFrame.paintEvent(self, event)
def setup1(self):
self.colors = []
for n in range(256):
h = self.ntrp(n, 0, 256, 240, 60)
cn = self.ntrp(n, 0, 256, 80, 255)
self.colors.append(QColor.fromHsv(h, 255.0, cn))
def initTable(self):
commonIDs = set()
set1IDs = set()
set2IDs = set()
for a in self.set1:
set1IDs.add(a[0])
for a in self.set2:
set2IDs.add(a[0])
commonIDs = set1IDs.intersection(set2IDs)
commonRows = list()
listSet2 = list(self.set2)
for a in self.sorted_nicely(commonIDs):
for b in listSet2:
if a == b[0]:
commonRows.append(b)
# see dependent vector
dependentVectors = dict()
for a in commonRows:
for b in commonRows:
try:
if self.is_number(a[1]) and self.is_number(
b[1]) and self.is_number(a[2]) and self.is_number(
b[2]) and self.is_number(
a[3]) and self.is_number(b[3]):
kx = float(a[1]) / float(b[1])
ky = float(a[2]) / float(b[2])
kz = float(a[3]) / float(b[3])
if kx == ky and kx == kz and a != b:
randColor = QColor.fromHsv(qrand() % 256, 230, 220)
dependentVectors[a[0]] = randColor
dependentVectors[b[0]] = randColor
except ZeroDivisionError:
xxx = 0
#print("division by zero")
self.ui.tableWidgetZachytne.setRowCount(len(commonIDs))
self.ui.tableWidgetZachytne.setColumnCount(3)
rowIDs = list()
colIDs = list(["X", "Y", "Z"])
self.ui.tableWidgetZachytne.setHorizontalHeaderLabels(colIDs)
self.ui.tableWidgetZachytne.setSelectionBehavior(
QTableWidget.SelectRows)
row = 0
for curRow in commonRows:
xItem = QTableWidgetItem(curRow[1])
yItem = QTableWidgetItem(curRow[2])
zItem = QTableWidgetItem(curRow[3])
# if dependent : rows will be filled with same color
if curRow[0] in dependentVectors:
xItem.setBackground(dependentVectors[curRow[0]])
yItem.setBackground(dependentVectors[curRow[0]])
zItem.setBackground(dependentVectors[curRow[0]])
# bg color with red if not a number
if not self.is_number(curRow[1]):
xItem.setBackground(Qt.red)
# bg color with red if not a number
if not self.is_number(curRow[2]):
yItem.setBackground(Qt.red)
# bg color with red if not a number
if not self.is_number(curRow[3]):
zItem.setBackground(Qt.red)
self.ui.tableWidgetZachytne.setItem(row, 0, xItem)
self.ui.tableWidgetZachytne.setItem(row, 1, yItem)
self.ui.tableWidgetZachytne.setItem(row, 2, zItem)
rowIDs.append(str(curRow[0]))
row = row + 1
self.ui.tableWidgetZachytne.setVerticalHeaderLabels(rowIDs)
self.row2ID = rowIDs
QToolTip,
QStatusBar,
)
def limit_to_255(value: float) -> int:
return 255 if value > 255 else 0 if value < 0 else int(value)
_isMacHost = True
BASE_COLOR = QColor("#666666")
SIDEBAR_FONT_SIZE = (10 if _isMacHost else 7.5) * 1.2
MODEBAR_ICON_SIZE = 64
TOOLBAR_ICON_SHADOW = True
FLAT_STYLE = False
HIGHLIGHT_COLOR = QColor.fromHsv(BASE_COLOR.hue(), BASE_COLOR.saturation(),
limit_to_255(BASE_COLOR.value() * 1.16))
SHADOW_COLOR = QColor.fromHsv(BASE_COLOR.hue(),
limit_to_255(BASE_COLOR.saturation() * 1.1),
limit_to_255(BASE_COLOR.value() * 0.70))
BORDER_COLOR = QColor.fromHsv(BASE_COLOR.hue(), BASE_COLOR.saturation(),
limit_to_255(BASE_COLOR.value() / 2))
FancyToolButtonSelectedColor = QColor("#32000000")
FancyToolButtonHoverColor = QColor("#28ffffff")
FancyTabWidgetDisabledSelectedTextColor = QColor("#ffffffff")
FancyTabWidgetDisabledUnselectedTextColor = QColor("#78ffffff")
FancyTabWidgetEnabledSelectedTextColor = QColor("#ffcccccc")
FancyTabWidgetEnabledUnselectedTextColor = QColor("#ffffffff")
def disabledSideBarIcon(enabledicon: QPixmap) -> QPixmap:
im = enabledicon.toImage().convertToFormat(QImage.Format_ARGB32)
def hsvToQColor(hsv):
return QColor.fromHsv(hsv[0], hsvToQColor[1], hsvToQColor[2])
def randomItemColor(self):
return QColor.fromHsv(random.randint(0, 256), 255, 190)
def initialItemColor(self):
hue = ((len(self.shapeItems) + 1) * 85) % 256
return QColor.fromHsv(hue, 255, 190)
def randomItemColor(self):
return QColor.fromHsv(random.randint(0, 256), 255, 190)
class MarkItemBrowser(QtTreePropertyBrowser):
my_list = [
'耕地', '园地', '林地', '草地', '居民点及工矿', '交通用地', '水域及水利设施用地', '未利用地', '其他土地'
]
my_list_0 = ['水田', '水浇地', '旱地']
my_list_1 = ['果园', '茶园', '其他园地']
my_list_2 = ['林地', '灌木林地', '疏林地', '幼林地', '其他林地']
my_list_3 = ['高覆盖草地', '中高覆盖草地', '中覆盖草地', '中低覆盖草地', '低覆盖草地']
my_list_4 = ['城镇居民点', '农村居民点', '独立工矿用地', '商服及公共用地', '特殊用地']
my_list_5 = []
my_list_6 = []
my_list_7 = []
my_list_8 = ['盐碱地', '沙地', '沼泽地', '裸岩', '裸土']
my_list_0_0 = []
my_list_0_1 = []
my_list_0_2 = ['梯坪地', '坡耕地']
my_list_1_0 = []
my_list_1_1 = []
my_list_1_2 = []
my_list_2_0 = []
my_list_2_1 = []
my_list_2_2 = []
my_list_2_3 = []
my_list_2_4 = []
my_list_3_0 = []
my_list_3_1 = []
my_list_3_2 = []
my_list_3_3 = []
my_list_3_4 = []
my_list_4_0 = []
my_list_4_1 = []
my_list_4_2 = []
my_list_4_3 = []
my_list_4_4 = []
my_list_8_0 = []
my_list_8_1 = []
my_list_8_2 = []
my_list_8_3 = []
my_list_8_4 = []
remarks_3_0 = '覆盖度大于75%'
remarks_3_1 = '覆盖度60%～75%'
remarks_3_2 = '覆盖度45%～60%'
remarks_3_3 = '覆盖度30%～45%'
remarks_3_4 = '覆盖度小于30%'
remarks_7 = '荒地'
operate = ['无', '添加人员']
my_list_list = (my_list_0, my_list_1, my_list_2, my_list_3, my_list_4,
my_list_5, my_list_6, my_list_7, my_list_8)
color_qss = QColor()
color_dictionary = {
my_list_0[0]: QColor.fromHsv(0, 255, 255),
my_list_0[1]: QColor.fromHsv(12, 255, 255),
my_list_0_2[0]: QColor.fromHsv(24, 255, 255),
my_list_0_2[1]: QColor.fromHsv(36, 255, 255),
my_list_1[0]: QColor.fromHsv(48, 255, 255),
my_list_1[1]: QColor.fromHsv(60, 255, 255),
my_list_1[2]: QColor.fromHsv(72, 255, 255),
my_list_2[0]: QColor.fromHsv(84, 255, 255),
my_list_2[1]: QColor.fromHsv(96, 255, 255),
my_list_2[2]: QColor.fromHsv(108, 255, 255),
my_list_2[3]: QColor.fromHsv(120, 255, 255),
my_list_2[4]: QColor.fromHsv(132, 255, 255),
my_list_3[0]: QColor.fromHsv(144, 255, 255),
my_list_3[1]: QColor.fromHsv(156, 255, 255),
my_list_3[2]: QColor.fromHsv(168, 255, 255),
my_list_3[3]: QColor.fromHsv(180, 255, 255),
my_list_3[4]: QColor.fromHsv(192, 255, 255),
my_list_4[0]: QColor.fromHsv(204, 255, 255),
my_list_4[1]: QColor.fromHsv(216, 255, 255),
my_list_4[2]: QColor.fromHsv(228, 255, 255),
my_list_4[3]: QColor.fromHsv(240, 255, 255),
my_list_4[4]: QColor.fromHsv(252, 255, 255),
my_list[5]: QColor.fromHsv(264, 255, 255),
my_list[6]: QColor.fromHsv(276, 255, 255),
my_list[7]: QColor.fromHsv(288, 255, 255),
my_list_8[0]: QColor.fromHsv(300, 255, 255),
my_list_8[1]: QColor.fromHsv(312, 255, 255),
my_list_8[2]: QColor.fromHsv(324, 255, 255),
my_list_8[3]: QColor.fromHsv(336, 255, 255),
my_list_8[4]: QColor.fromHsv(348, 255, 255)
}
def __init__(self, mark_item, parent=None):
QtTreePropertyBrowser.__init__(self, parent)
self.__mark_item = mark_item
self.mark_name_manager = QtStringPropertyManager(self)
self.project_name = self.mark_name_manager.addProperty('项目名称')
self.person_name_group_manager = QtGroupPropertyManager(self)
self.person_name_group = self.person_name_group_manager.addProperty(
'项目标注人')
self.person_name_manager = QtStringPropertyManager(self)
self.person_name_add_manager = QtEnumPropertyManager(self)
self.person_name_add = self.person_name_add_manager.addProperty('操作')
self.date_manager = QtDatePropertyManager(self)
self.my_date = self.date_manager.addProperty('标注时间')
self.enum_manager = QtEnumPropertyManager(self)
self.type = self.enum_manager.addProperty('地物类型')
self.enum_manager1 = QtEnumPropertyManager(self)
self.type_1 = self.enum_manager1.addProperty('一级类名称')
self.enum_manager2 = QtEnumPropertyManager(self)
self.type_2 = self.enum_manager2.addProperty('二级类名称')
self.enum_manager3 = QtEnumPropertyManager(self)
self.type_3 = self.enum_manager3.addProperty('三级类名称')
self.enum_manager3.valueChangedSignal.connect(self.mark_type_changed)
self.manager = QtStringPropertyManager(self)
self.marks_widget = self.manager.addProperty('备注')
self.color_test_manager = CustomColorPropertyManager(self)
self.color_test = self.color_test_manager.addProperty('标注颜色')
self.visibility_manager = QtBoolPropertyManager(self)
self.visibility = self.visibility_manager.addProperty('可见性')
self.visibility_manager.valueChangedSignal.connect(
self.visible_changed)
self.lockablility_manager = QtBoolPropertyManager(self)
self.lockablility = self.lockablility_manager.addProperty('锁定')
self.lockablility_manager.valueChangedSignal.connect(
self.locked_changed)
self.fill_manager = QtBoolPropertyManager(self)
self.fill = self.fill_manager.addProperty('填充')
self.fill_manager.valueChangedSignal.connect(self.fill_changed)
self.fill_manager.setValue(self.fill, self.__mark_item.fill)
self.clarity_manager = QtBoolPropertyManager(self)
self.clarity = self.clarity_manager.addProperty('透明')
self.clarity_manager.valueChangedSignal.connect(self.clarity_changed)
self.clarity_manager.setValue(self.clarity, self.__mark_item.clarity)
self.__create_project_name(self.__mark_item.item_name)
self.__create_person_name(self.__mark_item.get_person_names())
# self.__create_date(self.__mark_item.date)
self.__create_type(self.__mark_item.mark_type)
self.__create_visibility(self.__mark_item.visible)
self.__create_lockability(self.__mark_item.locked)
self.__create_property_browser(self)
def qss_setting(self, Qcolor: QColor):
color_rgb = Qcolor.getRgb()
color_r = color_rgb[0]
color_g = color_rgb[1]
color_b = color_rgb[2]
string = 'QComboBox{color:rgb(' + str(color_r) + ',' + str(
color_g) + ',' + str(color_b) + ');}'
print(string)
self.setStyleSheet(string)
# def color_changed(self, item, color: QColor):
# self.__mark_item.color = self.color_qss
def __create_project_name(self, data_project_name):
self.mark_name_manager.setValue(self.project_name, data_project_name)
self.mark_name_manager.editor_finished_signal.connect(
self.mark_item_name_changed)
self.__mark_item.mark_item_name_changed.connect(
lambda _, new_name: self.mark_name_manager.setValue(
self.project_name, new_name))
def __create_person_name(self, data_person_name):
for i in data_person_name:
self.person_name = self.person_name_manager.addProperty('标注人员')
self.person_name_manager.setValue(self.person_name, i)
self.person_name_group.addSubProperty(self.person_name)
operate = QList(self.operate)
self.person_name_add_manager.setEnumNames(self.person_name_add,
operate)
self.person_name_add_manager.setValue(self.person_name_add, 0)
self.person_name_add_manager.valueChangedSignal.connect(
self.__function_person_name_add)
self.person_name_group.addSubProperty(self.person_name_add)
self.person_name_manager.editor_finished_signal.connect(
self.__person_name_changed)
def __create_date(self, data_date):
self.date_manager.setValue(self.my_date, data_date)
def __create_type(self, data_type):
types = QList(self.my_list)
self.enum_manager.setEnumNames(self.type, types)
self.enum_manager.setValue(self.type, data_type[0])
self.enum_manager.valueChangedSignal.connect(self.__enum_changed)
types_1 = QList(self.my_list)
self.enum_manager1.setEnumNames(self.type_1, types_1)
self.enum_manager1.setValue(self.type_1, data_type[0])
self.type.addSubProperty(self.type_1)
self.enum_manager1.valueChangedSignal.connect(self.__enum_changed)
types_2 = QList(self.my_list_0)
self.enum_manager2.setEnumNames(self.type_2, types_2)
self.enum_manager2.setValue(self.type_2, data_type[1])
self.type.addSubProperty(self.type_2)
self.enum_manager2.valueChangedSignal.connect(self.__enum_changed_2)
types_3 = QList(self.my_list_1_0)
self.enum_manager3.setEnumNames(self.type_3, types_3)
self.enum_manager3.setValue(self.type_3, data_type[2])
self.type.addSubProperty(self.type_3)
self.enum_manager3.valueChangedSignal.connect(self.__enum_changed_3)
if len(data_type) > 3:
self.manager.setValue(self.marks_widget, data_type[3])
self.type.addSubProperty(self.marks_widget)
self.color_test_manager.setValue(self.color_test,
self.__mark_item.color)
self.type.addSubProperty(self.color_test)
def __create_visibility(self, visibility):
self.visibility_manager.setValue(self.visibility, visibility)
def __create_lockability(self, lockability):
self.lockablility_manager.setValue(self.lockablility, lockability)
def __create_property_browser(self, browser: QtTreePropertyBrowser):
enum_fictory = QtEnumEditorFactory()
string_fictory = QtLineEditFactory()
bool_fictory = QtCheckBoxFactory()
color_test_fictory = CustomColorEditorFactory()
browser.setFactoryForManager(self.mark_name_manager, string_fictory)
browser.setFactoryForManager(self.person_name_manager, string_fictory)
browser.setFactoryForManager(self.person_name_add_manager,
enum_fictory)
browser.setFactoryForManager(self.enum_manager, enum_fictory)
browser.setFactoryForManager(self.enum_manager1, enum_fictory)
browser.setFactoryForManager(self.enum_manager2, enum_fictory)
browser.setFactoryForManager(self.enum_manager3, enum_fictory)
browser.setFactoryForManager(self.color_test_manager,
color_test_fictory)
browser.setFactoryForManager(self.visibility_manager, bool_fictory)
browser.setFactoryForManager(self.lockablility_manager, bool_fictory)
browser.setFactoryForManager(self.fill_manager, bool_fictory)
browser.setFactoryForManager(self.clarity_manager, bool_fictory)
browser.addProperty(self.project_name)
browser.addProperty(self.person_name_group)
browser.addProperty(self.my_date)
browser.addProperty(self.type)
browser.addProperty(self.visibility)
browser.addProperty(self.lockablility)
browser.addProperty(self.fill)
browser.addProperty(self.clarity)
def mark_item_name_changed(self, _property, value):
self.__mark_item.item_name = value
def __enum_changed(self, item, value):
if item == self.type:
self.enum_manager1.setValue(self.type_1, value)
else:
self.enum_manager.setValue(self.type, value)
if value == 0:
self.enum_manager2.setEnumNames(self.type_2, QList(self.my_list_0))
self.enum_manager2.setValue(self.type_2, 0)
self.enum_manager3.setEnumNames(self.type_3,
QList(self.my_list_0_0))
self.enum_manager3.setValue(self.type_3, 0)
self.manager.setObjectName('')
self.manager.setValue(self.marks_widget, '')
elif value == 1:
self.enum_manager2.setEnumNames(self.type_2, QList(self.my_list_1))
self.enum_manager2.setValue(self.type_2, 0)
self.enum_manager3.setEnumNames(self.type_3,
QList(self.my_list_1_0))
self.enum_manager3.setValue(self.type_3, 0)
self.manager.setObjectName('')
self.manager.setValue(self.marks_widget, '')
elif value == 2:
self.enum_manager2.setEnumNames(self.type_2, QList(self.my_list_2))
self.enum_manager2.setValue(self.type_2, 0)
self.enum_manager3.setEnumNames(self.type_3,
QList(self.my_list_2_0))
self.enum_manager3.setValue(self.type_3, 0)
self.manager.setObjectName('')
self.manager.setValue(self.marks_widget, '')
elif value == 3:
self.enum_manager2.setEnumNames(self.type_2, QList(self.my_list_3))
self.enum_manager2.setValue(self.type_2, 0)
self.enum_manager3.setEnumNames(self.type_3,
QList(self.my_list_3_0))
self.enum_manager3.setValue(self.type_3, 0)
self.manager.setObjectName('')
self.manager.setValue(self.marks_widget, self.remarks_3_0)
elif value == 4:
self.enum_manager2.setEnumNames(self.type_2, QList(self.my_list_4))
self.enum_manager2.setValue(self.type_2, 0)
self.enum_manager3.setEnumNames(self.type_3,
QList(self.my_list_4_0))
self.enum_manager3.setValue(self.type_3, 0)
self.manager.setObjectName('')
self.manager.setValue(self.marks_widget, '')
elif value == 5:
self.enum_manager2.setEnumNames(self.type_2, QList(self.my_list_5))
self.enum_manager2.setValue(self.type_2, 0)
self.enum_manager3.setEnumNames(self.type_3, QList([]))
self.enum_manager3.setValue(self.type_3, 0)
self.manager.setObjectName('')
self.manager.setValue(self.marks_widget, '')
self.color_qss = self.color_dictionary[self.my_list[5]]
self.color_test_manager.setValue(self.color_test, self.color_qss)
elif value == 6:
self.enum_manager2.setEnumNames(self.type_2, QList(self.my_list_6))
self.enum_manager2.setValue(self.type_2, 0)
self.enum_manager3.setEnumNames(self.type_3, QList([]))
self.enum_manager3.setValue(self.type_3, 0)
self.manager.setObjectName('')
self.manager.setValue(self.marks_widget, '')
self.color_qss = self.color_dictionary[self.my_list[6]]
self.color_test_manager.setValue(self.color_test, self.color_qss)
elif value == 7:
self.enum_manager2.setEnumNames(self.type_2, QList(self.my_list_7))
self.enum_manager2.setValue(self.type_2, 0)
self.enum_manager3.setEnumNames(self.type_3, QList([]))
self.enum_manager3.setValue(self.type_3, 0)
self.manager.setObjectName('')
self.manager.setValue(self.marks_widget, self.remarks_7)
self.color_qss = self.color_dictionary[self.my_list[7]]
self.color_test_manager.setValue(self.color_test, self.color_qss)
elif value == 8:
self.enum_manager2.setEnumNames(self.type_2, QList(self.my_list_8))
self.enum_manager2.setValue(self.type_2, 0)
self.enum_manager3.setEnumNames(self.type_3,
QList(self.my_list_8_0))
self.enum_manager3.setValue(self.type_3, 0)
self.manager.setObjectName('')
self.manager.setValue(self.marks_widget, '')
self.mark_type_changed()
def __enum_changed_2(self, item, value):
now = self.enum_manager1.value(self.type_1)
print(now)
print(value)
if now == 0:
if value == 0:
self.enum_manager3.setEnumNames(self.type_3, QList([]))
self.enum_manager3.setValue(self.type_3, 0)
self.color_qss = self.color_dictionary[self.my_list_0[0]]
self.color_test_manager.setValue(self.color_test,
self.color_qss)
elif value == 1:
self.enum_manager3.setEnumNames(self.type_3, QList([]))
self.enum_manager3.setValue(self.type_3, 0)
self.color_qss = self.color_dictionary[self.my_list_0[1]]
self.color_test_manager.setValue(self.color_test,
self.color_qss)
elif value == 2:
self.enum_manager3.setEnumNames(self.type_3,
QList(self.my_list_0_2))
self.enum_manager3.setValue(self.type_3, 0)
elif now == 3:
if value == 0:
self.manager.setValue(self.marks_widget, self.remarks_3_0)
self.color_qss = self.color_dictionary[self.my_list_3[0]]
self.color_test_manager.setValue(self.color_test,
self.color_qss)
elif value == 1:
self.manager.setValue(self.marks_widget, self.remarks_3_1)
self.color_qss = self.color_dictionary[self.my_list_3[1]]
self.color_test_manager.setValue(self.color_test,
self.color_qss)
elif value == 2:
self.manager.setValue(self.marks_widget, self.remarks_3_2)
self.color_qss = self.color_dictionary[self.my_list_3[2]]
self.color_test_manager.setValue(self.color_test,
self.color_qss)
elif value == 3:
self.manager.setValue(self.marks_widget, self.remarks_3_3)
self.color_qss = self.color_dictionary[self.my_list_3[3]]
self.color_test_manager.setValue(self.color_test,
self.color_qss)
elif value == 4:
self.manager.setValue(self.marks_widget, self.remarks_3_4)
self.color_qss = self.color_dictionary[self.my_list_3[4]]
self.color_test_manager.setValue(self.color_test,
self.color_qss)
elif now == 5 or now == 6 or now == 7:
pass
else:
self.enum_manager3.setEnumNames(self.type_3, QList([]))
self.enum_manager3.setValue(self.type_3, 0)
linshi = self.my_list_list[now]
self.color_qss = self.color_dictionary[linshi[value]]
self.color_test_manager.setValue(self.color_test, self.color_qss)
self.mark_type_changed()
def __enum_changed_3(self, item, value):
type1 = self.enum_manager1.value(self.type_1)
type2 = self.enum_manager2.value(self.type_2)
self.color_qss = self.color_dictionary[self.my_list_0_2[value]]
self.color_test_manager.setValue(self.color_test, self.color_qss)
self.mark_type_changed()
def visible_changed(self, item, value):
self.__mark_item.visible = value
def locked_changed(self, item, value):
self.__mark_item.locked = value
def fill_changed(self, item, value):
self.__mark_item.fill = value
def clarity_changed(self, item, value):
self.__mark_item.clarity = value
def mark_type_changed(self):
make_type = [
self.enum_manager.value(self.type),
self.enum_manager2.value(self.type_2),
self.enum_manager3.value(self.type_3),
self.manager.value(self.marks_widget)
]
self.__mark_item.set_mark_type(tuple(make_type))
self.__mark_item.color = self.color_qss
def __person_name_changed(self, item: QtProperty, value):
if item.hasValue() and len(value) > 0:
return
else:
self.person_name_group.removeSubProperty(item)
def __function_person_name_add(self, item, value):
if value == 1:
self.person_name_group.removeSubProperty(self.person_name_add)
self.person_name = self.person_name_manager.addProperty('标注人员')
self.person_name_manager.setObjectName('')
self.person_name_manager.setValue(self.person_name, '')
self.person_name_group.addSubProperty(self.person_name)
self.person_name_add_manager.setValue(self.person_name_add, 0)
self.person_name_group.addSubProperty(self.person_name_add)
@property
def item_name(self):
project_name = self.mark_name_manager.value(self.project_name)
return project_name
@property
def person_names(self):
person_name_group = self.person_name_group.subProperties()
person_name = []
for i in person_name_group:
person_name.append(self.person_name_manager.value(i))
return person_name
@property
def date(self):
date = QDate.currentDate()
return date
@property
def item_color(self):
color = self.color_manager.value(self.color)
return color
@property
def mark_type(self):
type = []
type_1 = self.enum_manager1.value(self.type_1)
type.append(type_1)
type_2 = self.enum_manager2.value(self.type_2)
type.append(type_2)
type_3 = self.enum_manager3.value(self.type_3)
type.append(type_3)
remarks = self.manager.value(self.marks_widget)
type.append(remarks)
return type
@property
def visible(self):
return self.visibility
@property
def locked(self):
return self.lockablility
def list_detection_1(self, now):
string = 'self.my_list_' + str(now)
return string
def list_detection_2(self, now, value):
string = 'self.my_list_' + str(now) + '_' + str(value)
return string
def hsvToQColor(hsv) :
return QColor.fromHsv(hsv[0], hsvToQColor[1], hsvToQColor[2])
def initTable(self):
commonIDs = set()
set1IDs = set()
set2IDs = set()
for a in self.set1:
set1IDs.add(a[0])
for a in self.set2:
set2IDs.add(a[0])
commonIDs = set1IDs.intersection(set2IDs)
commonRows = list()
listSet2 = list(self.set2)
for a in self.sorted_nicely( commonIDs ):
for b in listSet2:
if a == b[0]:
commonRows.append(b)
# see dependent vector
dependentVectors = dict()
for a in commonRows:
for b in commonRows:
try:
if self.is_number(a[1]) and self.is_number(b[1]) and self.is_number(a[2]) and self.is_number(b[2]) and self.is_number(a[3]) and self.is_number(b[3]):
kx = float(a[1]) / float(b[1])
ky = float(a[2]) / float(b[2])
kz = float(a[3]) / float(b[3])
if kx == ky and kx == kz and a != b:
randColor = QColor.fromHsv(qrand() % 256, 230, 220)
dependentVectors[a[0]]=randColor
dependentVectors[b[0]]=randColor
except ZeroDivisionError:
xxx = 0
#print("division by zero")
self.ui.tableWidgetZachytne.setRowCount(len(commonIDs))
self.ui.tableWidgetZachytne.setColumnCount(3)
rowIDs = list()
colIDs = list(["X","Y","Z"])
self.ui.tableWidgetZachytne.setHorizontalHeaderLabels(colIDs)
self.ui.tableWidgetZachytne.setSelectionBehavior(QTableWidget.SelectRows)
row = 0
for curRow in commonRows:
xItem = QTableWidgetItem(curRow[1])
yItem = QTableWidgetItem(curRow[2])
zItem = QTableWidgetItem(curRow[3])
# if dependent : rows will be filled with same color
if curRow[0] in dependentVectors:
xItem.setBackground(dependentVectors[curRow[0]])
yItem.setBackground(dependentVectors[curRow[0]])
zItem.setBackground(dependentVectors[curRow[0]])
# bg color with red if not a number
if not self.is_number(curRow[1]):
xItem.setBackground(Qt.red)
# bg color with red if not a number
if not self.is_number(curRow[2]):
yItem.setBackground(Qt.red)
# bg color with red if not a number
if not self.is_number(curRow[3]):
zItem.setBackground(Qt.red)
self.ui.tableWidgetZachytne.setItem(row, 0, xItem)
self.ui.tableWidgetZachytne.setItem(row, 1, yItem)
self.ui.tableWidgetZachytne.setItem(row, 2, zItem)
rowIDs.append(str(curRow[0]))
row=row+1
self.ui.tableWidgetZachytne.setVerticalHeaderLabels(rowIDs)
self.row2ID = rowIDs
