def paint_extent(self, rec):
self.roi_x_max = rec.xMaximum()
self.ui.XMaxLineEdit.setText(str(round(rec.xMaximum(), 3)))
self.roi_y_min = rec.yMinimum()
self.ui.YMinLineEdit.setText(str(round(rec.yMinimum(), 3)))
self.roi_x_min = rec.xMinimum()
self.ui.XMinLineEdit.setText(str(round(rec.xMinimum(), 3)))
self.roi_y_max = rec.yMaximum()
self.ui.YMaxLineEdit.setText(str(round(rec.yMaximum(), 3)))
if self.extent:
self.canvas.scene().removeItem(self.extent)
self.extent = None
self.extent = QgsRubberBand(self.canvas, True)
points = [
QgsPoint(self.roi_x_max, self.roi_y_min),
QgsPoint(self.roi_x_max, self.roi_y_max),
QgsPoint(self.roi_x_min, self.roi_y_max),
QgsPoint(self.roi_x_min, self.roi_y_min),
QgsPoint(self.roi_x_max, self.roi_y_min)
]
self.extent.setToGeometry(QgsGeometry.fromPolyline(points), None)
self.extent.setColor(QColor(227, 26, 28, 255))
self.extent.setWidth(3)
self.extent.setLineStyle(Qt.PenStyle(Qt.DashLine))
self.canvas.refresh()
def __init__(self, canvas, callback):
self.canvas = canvas
QgsMapTool.__init__(self, self.canvas)
self.callback = callback
self.rubberBand = QgsRubberBand(self.canvas, True)
self.rubberBand.setColor(QColor(227, 26, 28, 255))
self.rubberBand.setWidth(3)
self.rubberBand.setLineStyle(Qt.PenStyle(Qt.DashLine))
self.reset()
def paint_extent(self, rectParams):
width = rectParams["width"]
height = rectParams["height"]
points = getPointsFromRectangleParams(rectParams)
# 0 W 1
# +---------------+
# | |
# H | + AuxPto
# | |
# +---------------+ ----------> rotation
# 3 W 2
self.roi_x_max = points[1][0]
self.ui.XMaxLineEdit.setText(str(round(self.roi_x_max, 3)))
self.roi_y_min = points[3][1]
self.ui.YMinLineEdit.setText(str(round(self.roi_y_min, 3)))
self.roi_x_min = points[3][0]
self.ui.XMinLineEdit.setText(str(round(self.roi_x_min, 3)))
self.roi_y_max = points[1][1]
self.ui.YMaxLineEdit.setText(str(round(self.roi_y_max, 3)))
self.ui.WidthGeoLineEdit.setText(str(round(width, 3)))
self.ui.HeightGeoLineEdit.setText(str(round(height, 3)))
if self.extent:
self.canvas.scene().removeItem(self.extent)
self.extent = None
if self.divisions:
self.canvas.scene().removeItem(self.divisions)
self.divisions = []
self.extent = QgsRubberBand(self.canvas, True)
points = [
QgsPoint(points[0][0], points[0][1]),
QgsPoint(points[1][0], points[1][1]),
QgsPoint(points[2][0], points[2][1]),
QgsPoint(points[3][0], points[3][1]),
QgsPoint(points[0][0], points[0][1])
]
self.extent.setToGeometry(QgsGeometry.fromPolyline(points), None)
self.extent.setColor(QColor(227, 26, 28, 255))
self.extent.setWidth(3)
self.extent.setLineStyle(Qt.PenStyle(Qt.DashLine))
self.paint_model_division()
self.canvas.refresh()
def paint_model_division(self):
if self.rect_Params is None:
return
if self.divisions:
self.canvas.scene().removeItem(self.divisions)
self.divisions = []
x_models = int(self.ui.ColPartsSpinBox.value())
y_models = int(self.ui.RowPartsSpinBox.value())
points = getPointsFromRectangleParams(self.rect_Params)
lines = []
if y_models > 1:
model_height = self.rect_Params["height"] / y_models
custRot = self.rect_Params['rotation'] - math.pi * 0.5
for i in range(1, y_models):
p1 = getPolarPoint(points[0][0], points[0][1], custRot,
model_height * i)
p2 = getPolarPoint(points[1][0], points[1][1], custRot,
model_height * i)
lines.append(
[QgsPointXY(p1[0], p1[1]),
QgsPointXY(p2[0], p2[1])])
if x_models > 1:
model_width = self.rect_Params["width"] / x_models
for i in range(1, x_models):
p1 = getPolarPoint(points[3][0], points[3][1],
self.rect_Params['rotation'],
model_width * i)
p2 = getPolarPoint(points[0][0], points[0][1],
self.rect_Params['rotation'],
model_width * i)
lines.append(
[QgsPointXY(p1[0], p1[1]),
QgsPointXY(p2[0], p2[1])])
if lines:
self.divisions = QgsRubberBand(self.canvas, False)
self.divisions.setColor(QColor(227, 26, 28, 255))
self.divisions.setWidth(3)
self.divisions.setLineStyle(Qt.PenStyle(Qt.DashDotLine))
self.divisions.setToGeometry(
QgsGeometry.fromMultiPolylineXY(lines), None)
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()
def style_maps(layer,
style_by,
iface,
output_type='damages-rlzs',
perils=None,
add_null_class=False,
render_higher_on_top=False,
repaint=True,
use_sgc_style=False):
symbol = QgsSymbol.defaultSymbol(layer.geometryType())
# see properties at:
# https://qgis.org/api/qgsmarkersymbollayerv2_8cpp_source.html#l01073
symbol.setOpacity(1)
if isinstance(symbol, QgsMarkerSymbol):
# do it only for the layer with points
symbol.symbolLayer(0).setStrokeStyle(Qt.PenStyle(Qt.NoPen))
style = get_style(layer, iface.messageBar())
# this is the default, as specified in the user settings
ramp = QgsGradientColorRamp(style['color_from'], style['color_to'])
style_mode = style['style_mode']
# in most cases, we override the user-specified setting, and use
# instead a setting that was required by scientists
if output_type in OQ_TO_LAYER_TYPES:
default_qgs_style = QgsStyle().defaultStyle()
default_color_ramp_names = default_qgs_style.colorRampNames()
if output_type in (
'damages-rlzs',
'avg_losses-rlzs',
'avg_losses-stats',
):
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.Jenks
else:
style_mode = 'Jenks'
ramp_type_idx = default_color_ramp_names.index('Reds')
symbol.setColor(QColor(RAMP_EXTREME_COLORS['Reds']['top']))
inverted = False
elif (output_type in ('gmf_data', 'ruptures')
or (output_type == 'hmaps' and not use_sgc_style)):
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if output_type == 'ruptures':
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.Pretty
else:
style_mode = 'PrettyBreaks'
else:
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.EqualInterval
else:
style_mode = 'EqualInterval'
ramp_type_idx = default_color_ramp_names.index('Spectral')
inverted = True
symbol.setColor(QColor(RAMP_EXTREME_COLORS['Reds']['top']))
elif output_type == 'hmaps' and use_sgc_style:
# FIXME: for SGC they were using size 10000 map units
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.Pretty
else:
style_mode = 'PrettyBreaks'
try:
ramp_type_idx = default_color_ramp_names.index(
'SGC_Green2Red_Hmap_Color_Ramp')
except ValueError:
raise ValueError(
'Color ramp SGC_Green2Red_Hmap_Color_Ramp was '
'not found. Please import it from '
'Settings -> Style Manager, loading '
'svir/resources/sgc_green2red_hmap_color_ramp.xml')
inverted = False
registry = QgsApplication.symbolLayerRegistry()
symbol_props = {
'name': 'square',
'color': '0,0,0',
'color_border': '0,0,0',
'offset': '0,0',
'size': '1.5', # FIXME
'angle': '0',
}
square = registry.symbolLayerMetadata(
"SimpleMarker").createSymbolLayer(symbol_props)
symbol = QgsSymbol.defaultSymbol(layer.geometryType()).clone()
symbol.deleteSymbolLayer(0)
symbol.appendSymbolLayer(square)
symbol.symbolLayer(0).setStrokeStyle(Qt.PenStyle(Qt.NoPen))
elif output_type in ['asset_risk', 'input']:
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.EqualInterval
else:
style_mode = 'EqualInterval'
# exposure_strings = ['number', 'occupants', 'value']
# setting exposure colors by default
colors = {
'single': RAMP_EXTREME_COLORS['Blues']['top'],
'ramp_name': 'Blues'
}
inverted = False
if output_type == 'asset_risk':
damage_strings = perils
for damage_string in damage_strings:
if damage_string in style_by:
colors = {
'single':
RAMP_EXTREME_COLORS['Spectral']['top'],
'ramp_name': 'Spectral'
}
inverted = True
break
else: # 'input'
colors = {
'single': RAMP_EXTREME_COLORS['Greens']['top'],
'ramp_name': 'Greens'
}
symbol.symbolLayer(0).setShape(
QgsSimpleMarkerSymbolLayerBase.Square)
single_color = colors['single']
ramp_name = colors['ramp_name']
ramp_type_idx = default_color_ramp_names.index(ramp_name)
symbol.setColor(QColor(single_color))
else:
raise NotImplementedError(
'Undefined color ramp for output type %s' % output_type)
ramp = default_qgs_style.colorRamp(
default_color_ramp_names[ramp_type_idx])
if inverted:
ramp.invert()
# get unique values
fni = layer.fields().indexOf(style_by)
unique_values = layer.dataProvider().uniqueValues(fni)
num_unique_values = len(unique_values - {NULL})
if num_unique_values > 2:
if Qgis.QGIS_VERSION_INT < 31000:
renderer = QgsGraduatedSymbolRenderer.createRenderer(
layer, style_by, min(num_unique_values, style['classes']),
style_mode, symbol.clone(), ramp)
else:
renderer = QgsGraduatedSymbolRenderer(style_by, [])
# NOTE: the following returns an instance of one of the
# subclasses of QgsClassificationMethod
classification_method = \
QgsApplication.classificationMethodRegistry().method(
style_mode)
renderer.setClassificationMethod(classification_method)
renderer.updateColorRamp(ramp)
renderer.updateSymbols(symbol.clone())
renderer.updateClasses(
layer, min(num_unique_values, style['classes']))
if not use_sgc_style:
if Qgis.QGIS_VERSION_INT < 31000:
label_format = renderer.labelFormat()
# NOTE: the following line might be useful
# label_format.setTrimTrailingZeroes(True)
label_format.setPrecision(2)
renderer.setLabelFormat(label_format, updateRanges=True)
else:
renderer.classificationMethod().setLabelPrecision(2)
renderer.calculateLabelPrecision()
elif num_unique_values == 2:
categories = []
for unique_value in unique_values:
symbol = symbol.clone()
try:
symbol.setColor(
QColor(RAMP_EXTREME_COLORS[ramp_name]
['bottom' if unique_value ==
min(unique_values) else 'top']))
except Exception:
symbol.setColor(
QColor(style['color_from'] if unique_value ==
min(unique_values) else style['color_to']))
category = QgsRendererCategory(unique_value, symbol,
str(unique_value))
# entry for the list of category items
categories.append(category)
renderer = QgsCategorizedSymbolRenderer(style_by, categories)
else:
renderer = QgsSingleSymbolRenderer(symbol.clone())
if add_null_class and NULL in unique_values:
# add a class for NULL values
rule_renderer = QgsRuleBasedRenderer(symbol.clone())
root_rule = rule_renderer.rootRule()
not_null_rule = root_rule.children()[0].clone()
# strip parentheses from stringified color HSL
not_null_rule.setFilterExpression(
'%s IS NOT NULL' % QgsExpression.quotedColumnRef(style_by))
not_null_rule.setLabel('%s:' % style_by)
root_rule.appendChild(not_null_rule)
null_rule = root_rule.children()[0].clone()
null_rule.setSymbol(
QgsFillSymbol.createSimple({
'color': '160,160,160',
'style': 'diagonal_x'
}))
null_rule.setFilterExpression(
'%s IS NULL' % QgsExpression.quotedColumnRef(style_by))
null_rule.setLabel(tr('No points'))
root_rule.appendChild(null_rule)
if isinstance(renderer, QgsGraduatedSymbolRenderer):
# create value ranges
rule_renderer.refineRuleRanges(not_null_rule, renderer)
# remove default rule
elif isinstance(renderer, QgsCategorizedSymbolRenderer):
rule_renderer.refineRuleCategoris(not_null_rule, renderer)
for rule in rule_renderer.rootRule().children()[1].children():
label = rule.label()
# by default, labels are like:
# ('"collapse-structural-ASH_DRY_sum" >= 0.0000 AND
# "collapse-structural-ASH_DRY_sum" <= 2.3949')
first, second = label.split(" AND ")
bottom = first.rsplit(" ", 1)[1]
top = second.rsplit(" ", 1)[1]
simplified = "%s - %s" % (bottom, top)
rule.setLabel(simplified)
root_rule.removeChildAt(0)
renderer = rule_renderer
if render_higher_on_top:
renderer.setUsingSymbolLevels(True)
symbol_items = [item for item in renderer.legendSymbolItems()]
for i in range(len(symbol_items)):
sym = symbol_items[i].symbol().clone()
key = symbol_items[i].ruleKey()
for lay in range(sym.symbolLayerCount()):
sym.symbolLayer(lay).setRenderingPass(i)
renderer.setLegendSymbolItem(key, sym)
layer.setRenderer(renderer)
if not use_sgc_style:
layer.setOpacity(0.7)
if repaint:
layer.triggerRepaint()
iface.setActiveLayer(layer)
iface.zoomToActiveLayer()
# NOTE QGIS3: probably not needed
# iface.layerTreeView().refreshLayerSymbology(layer.id())
iface.mapCanvas().refresh()
def setAvoidStyleSnapRubberBand(self):
self.rubberBand.setLineStyle(Qt.PenStyle(Qt.DashDotLine))
self.rubberBand.setSecondaryStrokeColor(QColor(255, 255, 0, 200))
self.rubberBand.setFillColor(QColor(255, 0, 0, 40))
def setAllowedStyleSnapRubberBand(self):
self.rubberBand.setLineStyle(Qt.PenStyle(Qt.SolidLine))
self.rubberBand.setSecondaryStrokeColor(QColor(255, 0, 0, 200))
self.rubberBand.setFillColor(QColor(255, 0, 0, 40))