def run(self):
# 非空检查
if self.radius_text.text().strip() == u"":
QMessageBox.critical(self, u"错误", u"请填写渲染半径！")
return
else:
self.accept()
self.radius = float(self.radius_text.text().strip())
self.quality = self.quality_combobox.currentIndex()
tra = QgsHeatmapRenderer() # 设置基站为热图样式
tra.setMaximumValue(0) # 默认渲染最大值为0（自动）
color_ramp = QgsVectorGradientColorRampV2(
QColor("white"), QColor("red"), False, [
QgsGradientStop(0.25, QColor("#00ffff")),
QgsGradientStop(0.50, QColor("#00ff00")),
QgsGradientStop(0.75, QColor("#ffff00"))
])
tra.setColorRamp(color_ramp)
self.color = tra.colorRamp()
tra.setRadius(self.radius)
tra.setRenderQuality(self.quality)
# 获取渲染字段
fieldName = self.field_conbobox.currentText()
tra.setWeightExpression(fieldName) # 根据字段渲染
self.layer.setRendererV2(tra)
# 获取渲染字段的最大值
max_value, min_value = self.getMaxAndMinValue(fieldName)
self.iface.actionDraw().trigger()
# 获取图例名称
legend_name = self.name_text.text()
legend = HeatRenderLegend(self.iface, self.styleManager, max_value,
min_value, legend_name, self.parent)
legend.show()
legend.exec_()
def color_layers(self):
"""
Attempts to assign and color each layer after changing it's renderer to a heatmap renderer
NOTE: This uses a Random sequence for color grading
TODO: Update color grading to generally output more readable colors Possibly make higher values have more radius?
:return: None
"""
p = QgsMapLayerRegistry.instance().mapLayers()
regex = re.compile("\n?(\D*)\d*\n?")
for key, val in p.iteritems():
try:
renderer = QgsHeatmapRenderer()
a = regex.match(key)
fcn = QgsVectorGradientColorRampV2()
renderer.setWeightExpression(a.group(1))
fcn.setColor1(QColor(255, 255, 255, 0))
fcn.setColor2(QColor(random.randint(0, 100), random.randint(
50, 255), random.randint(50, 255), 255))
renderer.setColorRamp(fcn)
renderer.setRenderQuality(1) # Max out the quality
val.setRendererV2(renderer)
except AttributeError:
continue
def color_layers(self):
"""
Attempts to assign and color each layer after changing it's renderer to the Categorized Symbol Renderer
TODO: Implement a store value to look up default names to get standardized Color Grading, If possible
:return: None
"""
p = QgsMapLayerRegistry.instance().mapLayers()
regex = re.compile("\n?(\D*)\d*\n?")
for key, val in p.iteritems():
try:
catagories = []
a = regex.match(key)
fcn = QgsVectorGradientColorRampV2()
# renderer.setWeightExpression(a.group(1))
# fcn.setColor1(QColor(255, 255, 255, 0))
# fcn.setColor2(QColor(random.randint(0, 100), random.randint(
# 50, 255), random.randint(50, 255), 255))
fcn.setColor1(QColor(255, 0, 0, 255))
fcn.setColor2(QColor(0, 255, 0, 255))
# self.com.log(str(fcn.stops()), level=0)
fcn.setStops([QgsGradientStop(0.5, QColor(255, 207, 74, 255))])
# renderer.setColorRamp(fcn)
# renderer.setRenderQuality(1) # Max out the quality
# for feature in val.getFeature():
# print feature.attribute(a.group(1))
fni = val.fieldNameIndex(a.group(1))
# This function is accomplishing the Classify Function, due to
# the lack of API implementation
sortedlist = []
for unique in val.dataProvider().uniqueValues(fni):
sortedlist.append(unique)
sortedlist.sort()
for i in sortedlist:
symbol = QgsSymbolV2.defaultSymbol(val.geometryType())
category = QgsRendererCategoryV2(i, symbol, str(i))
catagories.append(category)
renderer = QgsCategorizedSymbolRendererV2(
a.group(1), catagories)
self.com.log(str(renderer.categories()), level=0)
renderer.updateColorRamp(fcn)
# renderer.updateCategoryValue(a.group(1))
val.setRendererV2(renderer)
except AttributeError:
# This will allow the Color step to continue if it hits an
# Object it can't use (Raster layer)
continue
def add_symbology(self):
low_color = self.color_low_value.color()
high_color = self.color_high_value.color()
index = self.cbx_mode.currentIndex()
mode = self.cbx_mode.itemData(index)
classes = self.spinBox_classes.value()
# Compute renderer
# noinspection PyArgumentList
symbol = QgsSymbolV2.defaultSymbol(QGis.Polygon)
color_ramp = QgsVectorGradientColorRampV2(low_color, high_color)
# noinspection PyArgumentList
renderer = QgsGraduatedSymbolRendererV2.createRenderer(
self.output_layer, self.name_field, classes, mode, symbol,
color_ramp)
self.output_layer.setRendererV2(renderer)
def classified_style_from_interval(layer, cm):
def ramp_value(first_cm, last_cm, prev_item):
if prev_item < first_cm.value:
ramp_val = 0
elif prev_item > last_cm.value:
ramp_val = 1
else:
ramp_val = (prev_item - first_cm.value) / (last_cm.value -
first_cm.value)
return ramp_val
def gen_cl(ramp, val, ramp_val, label):
sym = QgsFillSymbolV2.createSimple({})
sym.setColor(ramp.color(ramp_val))
cat = QgsRendererCategoryV2(val, sym, label)
return cat
assert (layer)
last_index = cm.item_count() - 1
assert (last_index > 0) # at least 2 values
first_cm = cm.item(0)
last_cm = cm.item(last_index)
idx = layer.pendingFields().indexFromName("CVAL")
vals = layer.uniqueValues(idx)
ramp = QgsVectorGradientColorRampV2(QColor(*first_cm.color),
QColor(*last_cm.color))
cl = []
for i in range(1, len(vals)): # skip first one
item = vals[i]
prev_item = vals[i - 1]
label = str(item) + " - " + str(prev_item)
ramp_val = ramp_value(first_cm, last_cm, prev_item)
cl.append(gen_cl(ramp, prev_item, ramp_val, label))
last_item = vals[-1]
ramp_val = ramp_value(first_cm, last_cm, last_item)
cl.append(gen_cl(ramp, last_item, ramp_val, str(last_item)))
renderer = QgsCategorizedSymbolRendererV2("CVAL", cl)
layer.setRendererV2(renderer)
def createColorRamp():
return QgsVectorGradientColorRampV2(QColor(255, 0, 0), QColor(0, 0, 255))
def testQgsVectorGradientRampV2(self):
# test QgsGradientStop
stop = QgsGradientStop(0.9, QColor(200, 150, 100))
self.assertEqual(stop.offset, 0.9)
self.assertEqual(stop.color, QColor(200, 150, 100))
self.assertEqual(QgsGradientStop(0.1, QColor(180, 20, 30)), QgsGradientStop(0.1, QColor(180, 20, 30)))
self.assertNotEqual(QgsGradientStop(0.1, QColor(180, 20, 30)), QgsGradientStop(0.2, QColor(180, 20, 30)))
self.assertNotEqual(QgsGradientStop(0.1, QColor(180, 20, 30)), QgsGradientStop(0.1, QColor(180, 40, 30)))
# test gradient with only start/end color
r = QgsVectorGradientColorRampV2(QColor(200, 0, 0, 100), QColor(0, 200, 0, 200))
self.assertEqual(r.type(), 'gradient')
self.assertEqual(r.color1(), QColor(200, 0, 0, 100))
self.assertEqual(r.color2(), QColor(0, 200, 0, 200))
self.assertEqual(r.isDiscrete(), False)
self.assertEqual(len(r.stops()), 0)
self.assertEqual(r.count(), 2)
self.assertEqual(r.value(0), 0.0)
self.assertEqual(r.value(1), 1.0)
self.assertEqual(r.color(0), QColor(200, 0, 0, 100))
self.assertEqual(r.color(1), QColor(0, 200, 0, 200))
self.assertEqual(r.color(0.5), QColor(100, 100, 0, 150))
# test gradient with stops
r = QgsVectorGradientColorRampV2(QColor(200, 0, 0), QColor(0, 200, 0), False, [QgsGradientStop(0.1, QColor(180, 20, 40)),
QgsGradientStop(0.9, QColor(40, 60, 100))])
self.assertEqual(r.color1(), QColor(200, 0, 0))
self.assertEqual(r.color2(), QColor(0, 200, 0))
self.assertEqual(r.isDiscrete(), False)
self.assertEqual(len(r.stops()), 2)
self.assertEqual(r.count(), 4)
self.assertEqual(r.value(0), 0.0)
self.assertEqual(r.value(1), 0.1)
self.assertEqual(r.value(2), 0.9)
self.assertEqual(r.value(3), 1.0)
self.assertEqual(r.color(0), QColor(200, 0, 0))
self.assertEqual(r.color(0.05), QColor(190, 10, 20))
self.assertEqual(r.color(0.1), QColor(180, 20, 40))
self.assertEqual(r.color(0.5), QColor(110, 40, 70))
self.assertEqual(r.color(0.9), QColor(40, 60, 100))
self.assertEqual(r.color(0.95), QColor(20, 130, 50))
self.assertEqual(r.color(1), QColor(0, 200, 0))
# test setters
r.setColor1(QColor(0, 0, 200))
self.assertEqual(r.color1(), QColor(0, 0, 200))
self.assertEqual(r.color(0), QColor(0, 0, 200))
r.setColor2(QColor(0, 0, 100))
self.assertEqual(r.color2(), QColor(0, 0, 100))
self.assertEqual(r.color(1.0), QColor(0, 0, 100))
r.setStops([QgsGradientStop(0.4, QColor(100, 100, 40))])
s = r.stops()
self.assertEqual(len(s), 1)
self.assertEqual(s[0].offset, 0.4)
self.assertEqual(s[0].color, QColor(100, 100, 40))
# test info
r.setInfo({'key1': 'val1', 'key2': 'val2'})
self.assertEqual(r.info()['key1'], 'val1')
self.assertEqual(r.info()['key2'], 'val2')
# test creating from properties
props = r.properties()
fromProps = QgsVectorGradientColorRampV2.create(props)
self.assertEqual(fromProps.color1(), QColor(0, 0, 200))
self.assertEqual(fromProps.color2(), QColor(0, 0, 100))
s = fromProps.stops()
self.assertEqual(len(s), 1)
self.assertEqual(s[0].offset, 0.4)
c = QColor(s[0].color)
self.assertEqual(c, QColor(100, 100, 40))
self.assertEqual(fromProps.info()['key1'], 'val1')
self.assertEqual(fromProps.info()['key2'], 'val2')
self.assertEqual(fromProps.isDiscrete(), False)
# test cloning ramp
cloned = r.clone()
self.assertEqual(cloned.color1(), QColor(0, 0, 200))
self.assertEqual(cloned.color2(), QColor(0, 0, 100))
s = cloned.stops()
self.assertEqual(len(s), 1)
self.assertEqual(s[0].offset, 0.4)
c = QColor(s[0].color)
self.assertEqual(c, QColor(100, 100, 40))
self.assertEqual(cloned.info()['key1'], 'val1')
self.assertEqual(cloned.info()['key2'], 'val2')
self.assertEqual(cloned.isDiscrete(), False)
# test discrete ramps
# first with no stops
d = QgsVectorGradientColorRampV2(QColor(200, 0, 0), QColor(0, 200, 0), True)
self.assertEqual(d.isDiscrete(), True)
self.assertEqual(d.color(0), QColor(200, 0, 0))
self.assertEqual(d.color(0.5), QColor(200, 0, 0))
self.assertEqual(d.color(1), QColor(0, 200, 0))
# then with stops
d = QgsVectorGradientColorRampV2(QColor(200, 0, 0), QColor(0, 200, 0), True, [QgsGradientStop(0.1, QColor(180, 20, 40)),
QgsGradientStop(0.9, QColor(40, 60, 100))])
self.assertEqual(d.isDiscrete(), True)
self.assertEqual(d.color(0), QColor(200, 0, 0))
self.assertEqual(d.color(0.05), QColor(200, 0, 0))
self.assertEqual(d.color(0.1), QColor(180, 20, 40))
self.assertEqual(d.color(0.5), QColor(180, 20, 40))
self.assertEqual(d.color(0.9), QColor(40, 60, 100))
self.assertEqual(d.color(0.95), QColor(40, 60, 100))
self.assertEqual(d.color(1), QColor(0, 200, 0))
# to gradient
g = QGradient()
r = QgsVectorGradientColorRampV2(QColor(200, 0, 0), QColor(0, 200, 0), False, [QgsGradientStop(0.1, QColor(180, 20, 40)),
QgsGradientStop(0.9, QColor(40, 60, 100))])
r.addStopsToGradient(g, 0.5)
self.assertEqual(len(g.stops()), 4)
self.assertEqual(g.stops()[0], (0.0, QColor(200, 0, 0, 127)))
self.assertEqual(g.stops()[1], (0.1, QColor(180, 20, 40, 127)))
self.assertEqual(g.stops()[2], (0.9, QColor(40, 60, 100, 127)))
self.assertEqual(g.stops()[3], (1.0, QColor(0, 200, 0, 127)))
# test that stops are ordered when setting them
# first add some out-of-order stops
r.setStops([QgsGradientStop(0.4, QColor(100, 100, 40)),
QgsGradientStop(0.2, QColor(200, 200, 80)),
QgsGradientStop(0.8, QColor(50, 20, 10)),
QgsGradientStop(0.6, QColor(10, 10, 4))])
s = r.stops()
self.assertEqual(len(s), 4)
self.assertEqual(s[0].offset, 0.2)
self.assertEqual(s[0].color, QColor(200, 200, 80))
self.assertEqual(s[1].offset, 0.4)
self.assertEqual(s[1].color, QColor(100, 100, 40))
self.assertEqual(s[2].offset, 0.6)
self.assertEqual(s[2].color, QColor(10, 10, 4))
self.assertEqual(s[3].offset, 0.8)
self.assertEqual(s[3].color, QColor(50, 20, 10))
def style_maps(self, layer=None, style_by=None):
if layer is None:
layer = self.layer
if style_by is None:
style_by = self.default_field_name
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
# see properties at:
# https://qgis.org/api/qgsmarkersymbollayerv2_8cpp_source.html#l01073
symbol.setAlpha(1) # opacity
if isinstance(symbol, QgsMarkerSymbolV2):
# do it only for the layer with points
self._set_symbol_size(symbol)
symbol.symbolLayer(0).setOutlineStyle(Qt.PenStyle(Qt.NoPen))
style = get_style(layer, self.iface.messageBar())
# this is the default, as specified in the user settings
ramp = QgsVectorGradientColorRampV2(style['color_from'],
style['color_to'])
mode = style['mode']
# in most cases, we override the user-specified setting, and use
# instead a setting that was required by scientists
if self.output_type in OQ_TO_LAYER_TYPES:
default_qgs_style = QgsStyleV2().defaultStyle()
default_color_ramp_names = default_qgs_style.colorRampNames()
if self.output_type in ('dmg_by_asset', 'losses_by_asset',
'avg_losses-stats'):
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
mode = QgsGraduatedSymbolRendererV2.Jenks
ramp_type_idx = default_color_ramp_names.index('Reds')
inverted = False
elif self.output_type in ('hmaps', 'gmf_data', 'ruptures'):
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
if self.output_type == 'ruptures':
mode = QgsGraduatedSymbolRendererV2.Pretty
else:
mode = QgsGraduatedSymbolRendererV2.EqualInterval
ramp_type_idx = default_color_ramp_names.index('Spectral')
inverted = True
ramp = default_qgs_style.colorRamp(
default_color_ramp_names[ramp_type_idx])
graduated_renderer = QgsGraduatedSymbolRendererV2.createRenderer(
layer,
style_by,
style['classes'],
mode,
symbol,
ramp,
inverted=inverted)
label_format = graduated_renderer.labelFormat()
# label_format.setTrimTrailingZeroes(True) # it might be useful
label_format.setPrecision(2)
graduated_renderer.setLabelFormat(label_format, updateRanges=True)
# add a class for 0 values, unless while styling ruptures
if self.output_type != 'ruptures':
VERY_SMALL_VALUE = 1e-20
graduated_renderer.updateRangeLowerValue(0, VERY_SMALL_VALUE)
symbol_zeros = QgsSymbolV2.defaultSymbol(layer.geometryType())
symbol_zeros.setColor(QColor(240, 240, 240)) # very light grey
if isinstance(symbol, QgsMarkerSymbolV2):
# do it only for the layer with points
self._set_symbol_size(symbol_zeros)
symbol_zeros.symbolLayer(0).setOutlineStyle(
Qt.PenStyle(Qt.NoPen))
zeros_min = 0.0
zeros_max = VERY_SMALL_VALUE
range_zeros = QgsRendererRangeV2(
zeros_min, zeros_max, symbol_zeros,
" %.2f - %.2f" % (zeros_min, zeros_max), True)
graduated_renderer.addClassRange(range_zeros)
graduated_renderer.moveClass(
len(graduated_renderer.ranges()) - 1, 0)
layer.setRendererV2(graduated_renderer)
layer.setLayerTransparency(30) # percent
layer.triggerRepaint()
self.iface.legendInterface().refreshLayerSymbology(layer)
self.iface.mapCanvas().refresh()
# coding: utf-8
from qgis.core import QgsVectorGradientColorRampV2
from qgis.gui import QgsVectorGradientColorRampV2Dialog
vector_gradient_color_ramp_v2_dialog = QgsVectorGradientColorRampV2Dialog(
QgsVectorGradientColorRampV2())
vector_gradient_color_ramp_v2_dialog.show()
if Discrete == True:
stop1 = QgsGradientStop(
0.5,
QColor(int(split(tab[1], ',')[0]),
int(split(tab[1], ',')[1]),
int(split(tab[1], ',')[2])))
stops = [stop1]
discrete = True
color1 = QColor(int(split(tab[0], ',')[0]),
int(split(tab[0], ',')[1]),
int(split(tab[0], ',')[2]))
color2 = QColor(int(split(tab[1], ',')[0]),
int(split(tab[1], ',')[1]),
int(split(tab[1], ',')[2]))
colorRamp = QgsVectorGradientColorRampV2(
color1, color2, discrete, stops)
myStyle = QgsStyleV2().defaultStyle()
myStyle.addColorRamp(Style_name, colorRamp, True)
else:
discrete = False
color1 = QColor(int(split(tab[0], ',')[0]),
int(split(tab[0], ',')[1]),
int(split(tab[0], ',')[2]))
color2 = QColor(int(split(tab[1], ',')[0]),
int(split(tab[1], ',')[1]),
int(split(tab[1], ',')[2]))
colorRamp = QgsVectorGradientColorRampV2(
color1, color2, discrete)
