def _make_symbology(self, layer, min, max, title, color): """Creates the symbols and sets the coloring of the layer""" symbol = self._validated_default_symbol(layer.geometryType()) symbol.setColor(color) symbol.symbolLayer(0).setOutlineColor(color) range = QgsRendererRangeV2(min, max, symbol, title) return range
def __getGraduatedSymbolRenderer(self): """docstring for __getGraduatedSymbolRenderer""" #Comprobar que los atributos sean el mismo, sino renderizar por basado en reglas if len(set(self.attributes)) != 1: return self.__getRuleBasedRenderer() rangelist = [] field = self.has_classitem if self.has_classitem == self.attributes[ 0] else self.attributes[0] for exp, msclass in zip(self.expressions[::-1], self.mslayer["classes"][::-1]): Symbol = SymbolImport(msclass, self.qgslayer, self.geom_type, self.sizeunits, \ self.mssymbols, self.symbolsetpath, self.fontset) symbol = Symbol.getSymbol() label = msclass.get("name", exp[1]) render = False if msclass.get("status", 'on').lower() == 'off' else True rangelist.append( QgsRendererRangeV2(exp[3], exp[4], symbol, label, render)) renderer = QgsGraduatedSymbolRendererV2(field, rangelist) renderer.setMode(QgsGraduatedSymbolRendererV2.Custom) return renderer
def symbolize(self): # define ranges: label, lower value, upper value, color name temp_cat = (('0-10', 0.0, 10.0, '"#0024E3'), ('10-12', 10.0, 12.0, '#0087CD'), ('12-14', 12.0, 14.0, '#16F45A'), ('14-16', 14.0, 16.0, '#73FF1A'), ('16-18', 16.0, 18.0, '#BDFF0C'), ('18-20', 18.0, 20.0, '#FFDD00'), ('20-22', 20.0, 22.0, '#FF9000'), ('22-24', 22.0, 24.0, '#FF4400'), ('24-26', 24.0, 26.0, '#FF1D00'), ('26-28', 26.0, 28.0, 'F70000'), ('>28', 28.0, 40.0, '#AA0000')) # create a category for each item in Augmean ranges = [] for label, lower, upper, color in temp_cat: symbol = QgsSymbolV2.defaultSymbol(self.layer.geometryType()) symbol.setColor(QColor(color)) symbol.setWidth(0.5) rng = QgsRendererRangeV2(lower, upper, symbol, label) ranges.append(rng) # create the renderer and assign it to a layer expression = [] for feature in layer.getFeatures(): attrs = feature.attributes() sum(attrs[29:33]) / 6 self.renderer = QgsGraduatedSymbolRendererV2(expression, ranges)
def showLegend(self, layer, field, setting_list): if not self.cellstyle: self.styleManager = QgsMapLayerStyleManager(layer) self.styleManager.addStyleFromLayer(u'默认') self.cellstyle = True ranges = [] flabel = QLabel(field) fl = QHBoxLayout() fl.addWidget(flabel) self.vbox.addLayout(fl) for bl in setting_list: widget = QWidget(self) widget.setStyleSheet('QWidget {background-color:%s}' % bl[0].name()) widget.resize(20, 20) label = QLabel(str(bl[1]) + u'—' + str(bl[2])) c = QHBoxLayout() c.addWidget(widget) c.addWidget(label) c.setStretchFactor(widget, 1) c.setStretchFactor(label, 3) self.vbox.addLayout(c) sym = QgsSymbolV2.defaultSymbol(layer.geometryType()) sym.setColor(bl[0]) rng = QgsRendererRangeV2(bl[1], bl[2], sym, label.text()) ranges.append(rng) self.vbox.addStretch(1) self.setLayout(self.vbox) renderer = QgsGraduatedSymbolRendererV2(field, ranges) layer.setRendererV2(renderer) self.iface.actionDraw().trigger()
def createChoropleth(self, layer, min, max, num_classes=10): myTargetField = HASC().valueField myRangeList = [] myOpacity = 1 step = (max - min) / num_classes col_step = 256 / (num_classes - 1) for i in range(num_classes): label = str(min + step * i) + " - " + str(min + step * (i + 1)) hex_level = hex(int(col_step * i)).split('x')[1] if (len(hex_level) < 2): hex_level = "0" + hex_level colour = "#" + hex_level + hex_level + hex_level symbol = QgsFillSymbolV2.createSimple({ 'color': colour, 'color_border': colour, 'width_border': '0' }) symbol.setAlpha(myOpacity) myRangeList.append( QgsRendererRangeV2(min + step * i, min + step * (i + 1), symbol, label)) renderer = QgsGraduatedSymbolRendererV2('', myRangeList) renderer.setMode(QgsGraduatedSymbolRendererV2.EqualInterval) renderer.setClassAttribute(myTargetField) layer.setRendererV2(renderer)
def render_and_save_pointwise_output_layer( self, pointwise_output_csv_filepath, output_layer_name, on_values_of_attribute, graduated_rendering_interval_points, shapefile_path=''): uri = 'file:///' + pointwise_output_csv_filepath + \ '?delimiter=%s&crs=epsg:32643&xField=%s&yField=%s' % (',', 'X', 'Y') output_layer = QgsVectorLayer(uri, output_layer_name, 'delimitedtext') if 'Crop' in on_values_of_attribute: ET_D_max = max([ point.budget.PET_minus_AET_crop_end for point in model_calculator.output_grid_points ]) elif 'Monsoon' in on_values_of_attribute: ET_D_max = max([ point.budget.PET_minus_AET_monsoon_end for point in model_calculator.output_grid_points ]) graduated_symbol_renderer_range_list = [] opacity = 1 intervals_count = len(graduated_rendering_interval_points) for i in range(intervals_count): interval_min = 0 if graduated_rendering_interval_points[ i] == 0 else ( graduated_rendering_interval_points[i] * ET_D_max / 100.0 + 0.01) interval_max = (graduated_rendering_interval_points * ET_D_max / 100.0) label = "{0:.2f} - {1:.2f}".format(interval_min, interval_max) colour = QColor( int(255 * (1 - (i + 1.0) / (intervals_count + 1.0))), 0, 0) # +1 done to tackle boundary cases symbol = QgsSymbolV2.defaultSymbol(output_layer.geometryType()) symbol.setColor(colour) symbol.setAlpha(opacity) interval_range = QgsRendererRangeV2(interval_min, interval_max, symbol, label) graduated_symbol_renderer_range_list.append(interval_range) renderer = QgsGraduatedSymbolRendererV2( '', graduated_symbol_renderer_range_list) renderer.setMode(QgsGraduatedSymbolRendererV2.EqualInterval) renderer.setClassAttribute(on_values_of_attribute) output_layer.setRendererV2(renderer) QgsMapLayerRegistry.instance().addMapLayer(output_layer) if shapefile_path != '': QgsVectorFileWriter.writeAsVectorFormat(output_layer, shapefile_path, "utf-8", None, "ESRI Shapefile") return output_layer
def testConvertFromGraduatedRenderer(self): # Test converting graduated renderer to rule based # First, try with a field based category (id) ranges = [] ranges.append(QgsRendererRangeV2(0, 1, QgsMarkerSymbolV2(), "0-1")) ranges.append(QgsRendererRangeV2(1, 2, QgsMarkerSymbolV2(), "1-2")) g = QgsGraduatedSymbolRendererV2("id", ranges) r = QgsRuleBasedRendererV2.convertFromRenderer(g) self.assertEqual(r.rootRule().children()[0].filterExpression(), '"id" >= 0.000000 AND "id" <= 1.000000') self.assertEqual(r.rootRule().children()[1].filterExpression(), '"id" > 1.000000 AND "id" <= 2.000000') # Next try with an expression based range ranges = [] ranges.append(QgsRendererRangeV2(0, 1, QgsMarkerSymbolV2(), "0-1")) ranges.append(QgsRendererRangeV2(1, 2, QgsMarkerSymbolV2(), "1-2")) g = QgsGraduatedSymbolRendererV2("id / 2", ranges) r = QgsRuleBasedRendererV2.convertFromRenderer(g) self.assertEqual(r.rootRule().children()[0].filterExpression(), '(id / 2) >= 0.000000 AND (id / 2) <= 1.000000') self.assertEqual(r.rootRule().children()[1].filterExpression(), '(id / 2) > 1.000000 AND (id / 2) <= 2.000000') # Last try with an expression which is just a quoted field name ranges = [] ranges.append(QgsRendererRangeV2(0, 1, QgsMarkerSymbolV2(), "0-1")) ranges.append(QgsRendererRangeV2(1, 2, QgsMarkerSymbolV2(), "1-2")) g = QgsGraduatedSymbolRendererV2('"id"', ranges) r = QgsRuleBasedRendererV2.convertFromRenderer(g) self.assertEqual(r.rootRule().children()[0].filterExpression(), '"id" >= 0.000000 AND "id" <= 1.000000') self.assertEqual(r.rootRule().children()[1].filterExpression(), '"id" > 1.000000 AND "id" <= 2.000000')
def testRefineWithRanges(self): #Test refining rule with ranges (refs #10815) #First, try with a field based category (id) ranges = [] ranges.append(QgsRendererRangeV2(0, 1, QgsMarkerSymbolV2(), "0-1")) ranges.append(QgsRendererRangeV2(1, 2, QgsMarkerSymbolV2(), "1-2")) g = QgsGraduatedSymbolRendererV2("id", ranges) QgsRuleBasedRendererV2.refineRuleRanges(self.r2, g) assert self.r2.children()[0].filterExpression() == '"id" >= 0.0000 AND "id" <= 1.0000' assert self.r2.children()[1].filterExpression() == '"id" > 1.0000 AND "id" <= 2.0000' #Next try with an expression based range ranges = [] ranges.append(QgsRendererRangeV2(0, 1, QgsMarkerSymbolV2(), "0-1")) ranges.append(QgsRendererRangeV2(1, 2, QgsMarkerSymbolV2(), "1-2")) g = QgsGraduatedSymbolRendererV2("id / 2", ranges) QgsRuleBasedRendererV2.refineRuleRanges(self.r1, g) assert self.r1.children()[0].filterExpression() == '(id / 2) >= 0.0000 AND (id / 2) <= 1.0000' assert self.r1.children()[1].filterExpression() == '(id / 2) > 1.0000 AND (id / 2) <= 2.0000' #Last try with an expression which is just a quoted field name ranges = [] ranges.append(QgsRendererRangeV2(0, 1, QgsMarkerSymbolV2(), "0-1")) ranges.append(QgsRendererRangeV2(1, 2, QgsMarkerSymbolV2(), "1-2")) g = QgsGraduatedSymbolRendererV2('"id"', ranges) QgsRuleBasedRendererV2.refineRuleRanges(self.r3, g) assert self.r3.children()[0].filterExpression() == '"id" >= 0.0000 AND "id" <= 1.0000' assert self.r3.children()[1].filterExpression() == '"id" > 1.0000 AND "id" <= 2.0000'
def prepare_renderer(levels, inter_time, lenpoly): cats = [('{} - {} min'.format(levels[i] - inter_time, levels[i]), levels[i] - inter_time, levels[i]) for i in xrange(lenpoly)] # label, lower bound, upper bound colors = get_isochrones_colors(len(levels)) ranges = [] for ix, cat in enumerate(cats): symbol = QgsFillSymbolV2() symbol.setColor(QtGui.QColor(colors[ix])) rng = QgsRendererRangeV2(cat[1], cat[2], symbol, cat[0]) ranges.append(rng) expression = 'max' return QgsGraduatedSymbolRendererV2(expression, ranges)
def testQgsRendererRangeV2_1(self): """Test QgsRendererRangeV2 getter/setter functions""" range = QgsRendererRangeV2() self.assertTrue(range) lower = 123.45 upper = 234.56 label = "Test label" symbol = createMarkerSymbol() range.setLowerValue(lower) self.assertEqual(range.lowerValue(), lower, "Lower value getter/setter failed") range.setUpperValue(upper) self.assertEqual(range.upperValue(), upper, "Upper value getter/setter failed") range.setLabel(label) self.assertEqual(range.label(), label, "Label getter/setter failed") range.setRenderState(True) self.assertTrue(range.renderState(), "Render state getter/setter failed") range.setRenderState(False) self.assertFalse(range.renderState(), "Render state getter/setter failed") range.setSymbol(symbol.clone()) self.assertEqual(symbol.dump(), range.symbol().dump(), "Symbol getter/setter failed") range2 = QgsRendererRangeV2(lower, upper, symbol.clone(), label, False) self.assertEqual(range2.lowerValue(), lower, "Lower value from constructor failed") self.assertEqual(range2.upperValue(), upper, "Upper value from constructor failed") self.assertEqual(range2.label(), label, "Label from constructor failed") self.assertEqual(range2.symbol().dump(), symbol.dump(), "Symbol from constructor failed") self.assertFalse(range2.renderState(), "Render state getter/setter failed")
def setGraduatedStyle(vl, ranges, field, **kwargs): """ set a graduated style """ # make a symbol for each range rangeV2List = [] for min_val, max_val, attrs in ranges: if 'label' in attrs: label = attrs['label'] #elif min_val == None: # label = u'%s <= %s' % (field, max_val) #elif max_val == None: # label = u'%s > %s' % (field, min_val) else: label = u'%s < %s <= %s' % (min_val, field, max_val) symbolV2 = QgsSymbolV2.defaultSymbol(vl.geometryType()) if 'color' in attrs: symbolV2.setColor(attrs['color']) if 'size' in attrs: symbolV2.setSize(attrs['size']) # from QGis > 1.8 QgsMarkerSymbolV2 has 2 scale methods: ScaleArea and ScaleDiameter if 'sizeScaleMethod' in kwargs and hasattr(symbolV2, 'setScaleMethod'): symbolV2.setScaleMethod(kwargs['sizeScaleMethod']) rangeV2 = QgsRendererRangeV2(min_val, max_val, symbolV2, label) rangeV2List.append(rangeV2) # create the renderer renderer = QgsGraduatedSymbolRendererV2(field, rangeV2List) # set size scale field if 'sizeScaleField' in kwargs: renderer.setSizeScaleField(kwargs['sizeScaleField']) # set the renderer for the layer vl.setRendererV2(renderer) Utils.iface.legendInterface().refreshLayerSymbology(vl)
def setBpejStyle(self, layer): # define ranges: label, lower value, upper value, hex value of color k_values = ( (self.tr('0.0-0.1'), 0.0, 0.1, '#458b00'), (self.tr('0.1-0.2'), 0.1, 0.2, '#bcee68'), (self.tr('0.2-0.3'), 0.2, 0.3, '#eedd82'), (self.tr('0.3-0.4'), 0.3, 0.4, '#ffa07a'), (self.tr('0.4-0.5'), 0.4, 0.5, '#ff4500'), (self.tr('0.5 and more'), 0.5, 9999.0, '#8b2500'), ) # create a category for each item in k_values ranges = [] for label, lower, upper, color in k_values: symbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) symbol.setColor(QColor(color)) rng = QgsRendererRangeV2(lower, upper, symbol, label) ranges.append(rng) # create the renderer and assign it to a layer expression = 'K' # field name renderer = QgsGraduatedSymbolRendererV2(expression, ranges) layer.setRendererV2(renderer)
def updateSymbology(self): if self._layer and self._layer.isValid(): att_values = [ f[self.target_field] for f in self._layer.dataProvider().getFeatures() ] intervs = self._intervalValues(att_values) colors = self._colorValues() range_list = [] for v_min, v_max, col in zip(intervs[:-1], intervs[1:], colors): symbol = QgsSymbolV2.defaultSymbol(self._layer.geometryType()) symbol.setColor(col) symbol.setWidth(self.LINE_WIDTH_PIX) label = '{:0.2f}%->{:0.2f}%'.format(v_min, v_max) range_ = QgsRendererRangeV2(v_min, v_max, symbol, label) range_list.append(range_) renderer = QgsGraduatedSymbolRendererV2('', range_list) renderer.setMode(QgsGraduatedSymbolRendererV2.Custom) renderer.setClassAttribute(self.target_field) self._layer.setRendererV2(renderer) self._layer.triggerRepaint()
def setVectorErosionStyle(self, layer): # define ranges: label, lower value, upper value, hex value of color g_values = ( (self.tr('Very weakly endangered'), 0.0, 1.0, '#458b00'), (self.tr('Weakly endangered'), 1.0, 2.0, '#bcee68'), (self.tr('Moderately endangered'), 2.0, 4.0, '#eedd82'), (self.tr('Severely endangered'), 4.0, 8.0, '#ffa07a'), (self.tr('Very severely endangered'), 8.0, 10.0, '#ff4500'), (self.tr('Extremely endangered'), 10.0, 999999.9, '#8b2500'), ) # create a category for each item in g_values ranges = [] for label, lower, upper, color in g_values: symbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) symbol.setColor(QColor(color)) rng = QgsRendererRangeV2(lower, upper, symbol, label) ranges.append(rng) # create the renderer and assign it to a layer expression = 'G' # field name renderer = QgsGraduatedSymbolRendererV2(expression, ranges) layer.setRendererV2(renderer)
def set_vector_graduated_style(vector_layer, style): """Set graduated QGIS vector style based on InaSAFE style dictionary. For **opaque** a value of **0** can be used. For **fully transparent**, a value of **100** can be used. The calling function should take care to scale the transparency level to between 0 and 100. :param vector_layer: A QGIS vector layer that will be styled. :type vector_layer: QgsVectorLayer, QgsMapLayer :param style: Dictionary of the form as in the example below :type style: dict :returns: None - Sets and saves style for vector_layer Example style:: {'target_field': 'DMGLEVEL', 'style_classes': [{'transparency': 1, 'max': 1.5, 'colour': '#fecc5c', 'min': 0.5, 'label': '[0.5 - 1.5] Low damage', 'size' : 1}, {'transparency': 55, 'max': 2.5, 'colour': '#fd8d3c', 'min': 1.5, 'label': '[1.5 - 2.5] Medium damage', 'size' : 1}, {'transparency': 80, 'max': 3.5, 'colour': '#f31a1c', 'min': 2.5, 'label': '[2.5 - 3.5] High damage', 'size' : 1}]} .. note:: The transparency and size keys are optional. Size applies to points only. .. note:: you can optionally pass border_color also, if not color will be used .. note:: you can optionally pass data_defined also, this has to be a dictionary of property: expressions like {'color': 'color_hsv(%s, "pop"/%s*100, %s)' % (hue, max, val)} """ target_field = style['target_field'] style_classes = style['style_classes'] geometry_type = vector_layer.geometryType() range_list = [] for style_class in style_classes: # Transparency 100: transparent # Transparency 0: opaque size = 2 # mm if 'size' in style_class: size = style_class['size'] transparency_percent = 0 if 'transparency' in style_class: transparency_percent = style_class['transparency'] if 'min' not in style_class: raise StyleError('Style info should provide a "min" entry') if 'max' not in style_class: raise StyleError('Style info should provide a "max" entry') try: min_val = float(style_class['min']) except TypeError: raise StyleError('Class break lower bound should be a number.' 'I got %s' % style_class['min']) try: max_val = float(style_class['max']) except TypeError: raise StyleError('Class break upper bound should be a number.' 'I got %s' % style_class['max']) color = style_class['colour'] label = style_class['label'] color = QtGui.QColor(color) # noinspection PyArgumentList symbol = QgsSymbolV2.defaultSymbol(geometry_type) # We need to create a custom symbol layer as # the border colour of a symbol can not be set otherwise # noinspection PyArgumentList try: value = style_class['border_color'] border_color = QtGui.QColor(value) except KeyError: border_color = color if geometry_type == QGis.Point: symbol_layer = QgsSimpleMarkerSymbolLayerV2() symbol_layer.setBorderColor(border_color) symbol_layer.setSize(size) symbol.changeSymbolLayer(0, symbol_layer) elif geometry_type == QGis.Polygon: symbol_layer = QgsSimpleFillSymbolLayerV2() symbol_layer.setBorderColor(border_color) symbol.changeSymbolLayer(0, symbol_layer) else: # for lines we do nothing special as the property setting # below should give us what we require. pass try: value = style_class['border_wdth'] symbol_layer.setBorderWidth(value) except (NameError, KeyError): # use QGIS default border size # NameError is when symbol_layer is not defined (lines for example) # KeyError is when borderWidth is not defined if hasattr(symbol_layer, 'setBorderWidth') and \ geometry_type == QGis.Polygon: symbol_layer.setBorderWidth(0) # set data defined properties try: for prop, expr in style_class['data_defined'].iteritems(): symbol_layer.setDataDefinedProperty(prop, expr) except (NameError, KeyError): # NameError is when symbol_layer is not defined (lines for example) # KeyError is when data_defined is not defined pass symbol.setColor(color) # .. todo:: Check that vectors use alpha as % otherwise scale TS # Convert transparency % to opacity # alpha = 0: transparent # alpha = 1: opaque alpha = 1 - transparency_percent / 100.0 symbol.setAlpha(alpha) range_renderer = QgsRendererRangeV2(min_val, max_val, symbol, label) range_list.append(range_renderer) renderer = QgsGraduatedSymbolRendererV2('', range_list) renderer.setMode(QgsGraduatedSymbolRendererV2.EqualInterval) renderer.setClassAttribute(target_field) vector_layer.setRendererV2(renderer) vector_layer.saveDefaultStyle()
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 compute_and_display_cadastral_vulnerability(self, cadastral_layer, output_grid_points, output_cadastral_points, crop_index, crop_name, base_path): cadastral_points_per_plot = {} for p in (output_grid_points + output_cadastral_points): if p.cadastral_polygon is None: continue if p.lulc_type not in ['agriculture', 'fallow land']: continue if p.cadastral_polygon.id() in cadastral_points_per_plot: cadastral_points_per_plot[p.cadastral_polygon.id()].append( p.budget.PET_minus_AET_crop_end[crop_index]) else: cadastral_points_per_plot[p.cadastral_polygon.id()] = [ p.budget.PET_minus_AET_crop_end[crop_index] ] for k, v in cadastral_points_per_plot.items(): if len(v) > 0: cadastral_points_per_plot[k] = sum(v) / len(v) else: del cadastral_points_per_plot[k] # print cadastral_points_per_plot # Create duplicate cadastral layer in memory memory_cadastral_layer = QgsVectorLayer( 'Polygon?crs=epsg:32643', crop_name + ' Cadastral Level Vulnerability', 'memory') memory_cadastral_layer.startEditing() memory_cadastral_layer.dataProvider().addAttributes( cadastral_layer.qgsLayer.dataProvider().fields().toList()) memory_cadastral_layer.updateFields() dict_new_feature_id_to_old_feature_id = {} for old_plot_id in cadastral_points_per_plot: result, output_features = memory_cadastral_layer.dataProvider( ).addFeatures([cadastral_layer.feature_dict[old_plot_id]]) dict_new_feature_id_to_old_feature_id[ output_features[0].id()] = old_plot_id memory_cadastral_layer.dataProvider().addAttributes( [QgsField('Deficit', QVariant.Double)]) memory_cadastral_layer.updateFields() for new_feature in memory_cadastral_layer.getFeatures(): new_feature['Deficit'] = cadastral_points_per_plot[ dict_new_feature_id_to_old_feature_id[new_feature.id()]] memory_cadastral_layer.updateFeature(new_feature) memory_cadastral_layer.commitChanges() # Graduated Rendering graduated_symbol_renderer_range_list = [] ET_D_max = max(cadastral_points_per_plot.values()) opacity = 1 geometry_type = memory_cadastral_layer.geometryType() intervals_count = CADASTRAL_VULNERABILITY_DISPLAY_COLOUR_INTERVALS_COUNT dict_interval_colour = CADASTRAL_VULNERABILITY_DISPLAY_COLOURS_DICT for i in range(intervals_count): interval_min = 0 if i == 0 else (ET_D_max * float(i) / intervals_count) + 0.01 interval_max = ET_D_max * float(i + 1) / intervals_count label = "{0:.2f} - {1:.2f}".format(interval_min, interval_max) colour = QColor(*dict_interval_colour[i]) symbol = QgsSymbolV2.defaultSymbol(geometry_type) symbol.setColor(colour) symbol.setAlpha(opacity) interval_range = QgsRendererRangeV2(interval_min, interval_max, symbol, label) graduated_symbol_renderer_range_list.append(interval_range) renderer = QgsGraduatedSymbolRendererV2( '', graduated_symbol_renderer_range_list) renderer.setMode(QgsGraduatedSymbolRendererV2.EqualInterval) renderer.setClassAttribute('Deficit') memory_cadastral_layer.setRendererV2(renderer) QgsMapLayerRegistry.instance().addMapLayer(memory_cadastral_layer) memory_cadastral_layer.setCustomProperty('labeling', 'pal') memory_cadastral_layer.setCustomProperty('labeling/enabled', 'true') memory_cadastral_layer.setCustomProperty('labeling/fieldName', 'Number') memory_cadastral_layer.setCustomProperty('labeling/fontSize', '10') memory_cadastral_layer.setCustomProperty('labeling/placement', '0') memory_cadastral_layer.dataProvider().forceReload() memory_cadastral_layer.triggerRepaint() QgsVectorFileWriter.writeAsVectorFormat( memory_cadastral_layer, base_path + '/kharif_' + crop_name + '_cadastral_level_vulnerability.shp', "utf-8", None, "ESRI Shapefile")
def render_old(layer,field): myTargetField = field myRangeList = [] myOpacity = 1 # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#FFFFFF')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(-150.0,0.0,mySymbol,"No level") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#C0FFC0')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(0.1,34.9,mySymbol,"< 35 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#00CC00')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(35.0,39.9,mySymbol,"35 - 40 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#005000')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(40.0,44.9,mySymbol,"40 - 45 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#FFFF00')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(45.0,49.9,mySymbol,"45 - 50 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#FFC74A')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(50.0,54.9,mySymbol,"50 - 55 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#FF6600')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(55.0,59.9,mySymbol,"55 - 60 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#FF3333')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(60.0,64.9,mySymbol,"60 - 65 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#990033')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(65.0,69.9,mySymbol,"65 - 70 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#AD9AD6')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(70.0,74.9,mySymbol,"70 - 75 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#0000FF')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(75.0,79.9,mySymbol,"75 - 80 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#000066')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(80.0,150.0,mySymbol,"> 80 dB(A)") myRangeList.append(myRange) myRenderer = QgsGraduatedSymbolRendererV2('', myRangeList) myRenderer.setMode(QgsGraduatedSymbolRendererV2.EqualInterval) myRenderer.setClassAttribute(myTargetField) layer.setRendererV2(myRenderer) iface.legendInterface().refreshLayerSymbology(layer) #layer.reload() #iface.mapCanvas().refresh() layer.triggerRepaint()
def set_vector_graduated_style(vector_layer, style): """Set graduated QGIS vector style based on InaSAFE style dictionary. For **opaque** a value of **0** can be used. For **fully transparent**, a value of **100** can be used. The calling function should take care to scale the transparency level to between 0 and 100. :param vector_layer: A QGIS vector layer that will be styled. :type vector_layer: QgsVectorLayer, QgsMapLayer :param style: Dictionary of the form as in the example below :type style: dict :returns: None - Sets and saves style for vector_layer Example style:: {'target_field': 'DMGLEVEL', 'style_classes': [{'transparency': 1, 'max': 1.5, 'colour': '#fecc5c', 'min': 0.5, 'label': '[0.5 - 1.5] Low damage', 'size' : 1}, {'transparency': 55, 'max': 2.5, 'colour': '#fd8d3c', 'min': 1.5, 'label': '[1.5 - 2.5] Medium damage', 'size' : 1}, {'transparency': 80, 'max': 3.5, 'colour': '#f31a1c', 'min': 2.5, 'label': '[2.5 - 3.5] High damage', 'size' : 1}]} .. note:: The transparency and size keys are optional. Size applies to points only. """ myTargetField = style['target_field'] myClasses = style['style_classes'] myGeometryType = vector_layer.geometryType() myRangeList = [] for myClass in myClasses: # Transparency 100: transparent # Transparency 0: opaque mySize = 2 # mm if 'size' in myClass: mySize = myClass['size'] myTransparencyPercent = 0 if 'transparency' in myClass: myTransparencyPercent = myClass['transparency'] if 'min' not in myClass: raise StyleError('Style info should provide a "min" entry') if 'max' not in myClass: raise StyleError('Style info should provide a "max" entry') try: myMin = float(myClass['min']) except TypeError: raise StyleError('Class break lower bound should be a number.' 'I got %s' % myClass['min']) try: myMax = float(myClass['max']) except TypeError: raise StyleError('Class break upper bound should be a number.' 'I got %s' % myClass['max']) myColour = myClass['colour'] myLabel = myClass['label'] myColour = QtGui.QColor(myColour) # noinspection PyArgumentList mySymbol = QgsSymbolV2.defaultSymbol(myGeometryType) # We need to create a custom symbol layer as # the border colour of a symbol can not be set otherwise # noinspection PyArgumentList if myGeometryType == QGis.Point: mySymbolLayer = QgsSimpleMarkerSymbolLayerV2() mySymbolLayer.setBorderColor(myColour) mySymbolLayer.setSize(mySize) mySymbol.changeSymbolLayer(0, mySymbolLayer) elif myGeometryType == QGis.Polygon: mySymbolLayer = QgsSimpleFillSymbolLayerV2() mySymbolLayer.setBorderColor(myColour) mySymbol.changeSymbolLayer(0, mySymbolLayer) else: # for lines we do nothing special as the property setting # below should give us what we require. pass mySymbol.setColor(myColour) # .. todo:: Check that vectors use alpha as % otherwise scale TS # Convert transparency % to opacity # alpha = 0: transparent # alpha = 1: opaque alpha = 1 - myTransparencyPercent / 100.0 mySymbol.setAlpha(alpha) myRange = QgsRendererRangeV2(myMin, myMax, mySymbol, myLabel) myRangeList.append(myRange) myRenderer = QgsGraduatedSymbolRendererV2('', myRangeList) myRenderer.setMode(QgsGraduatedSymbolRendererV2.EqualInterval) myRenderer.setClassAttribute(myTargetField) vector_layer.setRendererV2(myRenderer) vector_layer.saveDefaultStyle()
values = ( ('-1 - -.75', -1, -.75, QColor('#ef8a62')), ('-.75 - -.5', -.75, -.5, QColor('#f1a587')), ('-.5 - -.25', -.5, -.25, QColor('#f3c0ac')), ('-.25 - 0', -.25, -0.001, QColor('#f5dbd1')), ('0', -0.001, 0.001, QColor('#f7f7f7')), ('0 - .25', 0.001, .25, QColor('#d3e3ed')), ('.25 - .5', .25, .5, QColor('#afd0e3')), ('.5 - .75', .5, .75, QColor('#8bbcd9')), ('.75 - 1', .75, 1.0, QColor('#67a9cf')), ) for label, min, max, color in values: symbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) symbol.setColor(color) rng = QgsRendererRangeV2(min, max, symbol, label) rangeList.append(rng) renderer = QgsGraduatedSymbolRendererV2( targetField, rangeList ) renderer.setMode(QgsGraduatedSymbolRendererV2.Custom) layer.setRendererV2(renderer) iface.mapCanvas().refreshAllLayers() img = QImage(QSize(800, 600), QImage.Format_ARGB32_Premultiplied) # set image's background color color = QColor(255, 255, 255) img.fill(color.rgb()) # create painter
def symbology_from_range(layer, min_val, max_val, color, title): symbol = get_default_symbol(layer.geometryType()) symbol.setColor(color) srange = QgsRendererRangeV2(min_val, max_val, symbol, title) return srange
def setVectorStyle(theQgisVectorLayer, theStyle): """Set QGIS vector style based on InaSAFE style dictionary. For **opaque** a value of **0** can be used. For **fully transparent**, a value of **100** can be used. The function should take care to scale the transparency level to between 0 and 100. Args: * theQgisVectorLayer: QgsMapLayer * theStyle: dict - Dictionary of the form as in the example below Returns: None - Sets and saves style for theQgisVectorLayer Raises: None Example: {'target_field': 'DMGLEVEL', 'style_classes': [{'transparency': 1, 'max': 1.5, 'colour': '#fecc5c', 'min': 0.5, 'label': 'Low damage', 'size' : 1}, {'transparency': 55, 'max': 2.5, 'colour': '#fd8d3c', 'min': 1.5, 'label': 'Medium damage', 'size' : 1}, {'transparency': 80, 'max': 3.5, 'colour': '#f31a1c', 'min': 2.5, 'label': 'High damage', 'size' : 1}]} .. note:: The transparency and size keys are optional. Size applies to points only. """ myTargetField = theStyle['target_field'] myClasses = theStyle['style_classes'] myGeometryType = theQgisVectorLayer.geometryType() myRangeList = [] for myClass in myClasses: # Transparency 100: transparent # Transparency 0: opaque mySize = 2 # mm if 'size' in myClass: mySize = myClass['size'] myTransparencyPercent = 0 if 'transparency' in myClass: myTransparencyPercent = myClass['transparency'] if 'min' not in myClass: raise StyleError('Style info should provide a "min" entry') if 'max' not in myClass: raise StyleError('Style info should provide a "max" entry') try: myMin = float(myClass['min']) except TypeError: raise StyleError('Class break lower bound should be a number.' 'I got %s' % myClass['min']) try: myMax = float(myClass['max']) except TypeError: raise StyleError('Class break upper bound should be a number.' 'I got %s' % myClass['max']) myColour = myClass['colour'] myLabel = myClass['label'] myColour = QtGui.QColor(myColour) mySymbol = QgsSymbolV2.defaultSymbol(myGeometryType) myColourString = "%s, %s, %s" % (myColour.red(), myColour.green(), myColour.blue()) # Work around for the fact that QgsSimpleMarkerSymbolLayerV2 # python bindings are missing from the QGIS api. # .. see:: http://hub.qgis.org/issues/4848 # We need to create a custom symbol layer as # the border colour of a symbol can not be set otherwise myRegistry = QgsSymbolLayerV2Registry.instance() if myGeometryType == QGis.Point: myMetadata = myRegistry.symbolLayerMetadata('SimpleMarker') # note that you can get a list of available layer properties # that you can set by doing e.g. # QgsSimpleMarkerSymbolLayerV2.properties() mySymbolLayer = myMetadata.createSymbolLayer( {'color_border': myColourString}) mySymbolLayer.setSize(mySize) mySymbol.changeSymbolLayer(0, mySymbolLayer) elif myGeometryType == QGis.Polygon: myMetadata = myRegistry.symbolLayerMetadata('SimpleFill') mySymbolLayer = myMetadata.createSymbolLayer( {'color_border': myColourString}) mySymbol.changeSymbolLayer(0, mySymbolLayer) else: # for lines we do nothing special as the property setting # below should give us what we require. pass mySymbol.setColor(myColour) # .. todo:: Check that vectors use alpha as % otherwise scale TS # Convert transparency % to opacity # alpha = 0: transparent # alpha = 1: opaque alpha = 1 - myTransparencyPercent / 100.0 mySymbol.setAlpha(alpha) myRange = QgsRendererRangeV2(myMin, myMax, mySymbol, myLabel) myRangeList.append(myRange) myRenderer = QgsGraduatedSymbolRendererV2('', myRangeList) myRenderer.setMode(QgsGraduatedSymbolRendererV2.EqualInterval) myRenderer.setClassAttribute(myTargetField) theQgisVectorLayer.setRendererV2(myRenderer) theQgisVectorLayer.saveDefaultStyle()
def render(layer,field): myTargetField = field myRangeList = [] myOpacity = 1 # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#D8D8D8')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(-150.0,0.0,mySymbol,"No level") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#FFFFFF')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(0.1,34.4,mySymbol,"< 35 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#238443')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(34.5,39.4,mySymbol,"35 - 39 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#78C679')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(39.5,44.4,mySymbol,"40 - 44 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#C2E699')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(44.5,49.4,mySymbol,"45 - 49 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#FFFFB2')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(49.5,54.4,mySymbol,"50 - 54 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#FECC5C')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(54.5,59.4,mySymbol,"55 - 59 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#FD8D3C')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(59.5,64.4,mySymbol,"60 - 64 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#FF0909')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(64.5,69.4,mySymbol,"65 - 69 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#B30622')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(69.5,74.4,mySymbol,"70 - 74 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#67033B')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(74.5,79.4,mySymbol,"75 - 79 dB(A)") myRangeList.append(myRange) # symbol mySymbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) mySymbol.setColor(QColor('#1C0054')) mySymbol.setAlpha(myOpacity) myRange = QgsRendererRangeV2(79.5,150.0,mySymbol,">= 80 dB(A)") myRangeList.append(myRange) myRenderer = QgsGraduatedSymbolRendererV2('', myRangeList) myRenderer.setMode(QgsGraduatedSymbolRendererV2.EqualInterval) myRenderer.setClassAttribute(myTargetField) layer.setRendererV2(myRenderer) iface.legendInterface().refreshLayerSymbology(layer) #layer.reload() #iface.mapCanvas().refresh() layer.triggerRepaint()
def testQgsRendererRangeV2LabelFormat_2(self): """Test QgsRendererRangeV2LabelFormat number format""" format = QgsRendererRangeV2LabelFormat() # Tests have precision, trim, value, expected # (Note: Not sure what impact of locale is on these tests) tests = ( (2, False, 1.0, '1.00'), (2, True, 1.0, '1'), (2, False, 1.234, '1.23'), (2, True, 1.234, '1.23'), (2, False, 1.236, '1.24'), (2, False, -1.236, '-1.24'), (2, False, -0.004, '0.00'), (2, True, 1.002, '1'), (2, True, 1.006, '1.01'), (2, True, 1.096, '1.1'), (3, True, 1.096, '1.096'), (-2, True, 1496.45, '1500'), (-2, True, 149.45, '100'), (-2, True, 79.45, '100'), (-2, True, 49.45, '0'), (-2, True, -49.45, '0'), (-2, True, -149.45, '-100'), ) for f in tests: precision, trim, value, expected = f format.setPrecision(precision) format.setTrimTrailingZeroes(trim) result = format.formatNumber(value) self.assertEqual( result, expected, "Number format error {0}:{1}:{2} => {3}".format( precision, trim, value, result)) # Label tests - label format, expected result. # Labels will be evaluated with lower=1.23 upper=2.34, precision=2 ltests = ( ("%1 - %2", "1.23 - 2.34"), ("%1", "1.23"), ("%2", "2.34"), ("%2%", "2.34%"), ("%1%1", "1.231.23"), ("from %1 to %2 metres", "from 1.23 to 2.34 metres"), ("from %2 to %1 metres", "from 2.34 to 1.23 metres"), ) format.setPrecision(2) format.setTrimTrailingZeroes(False) lower = 1.232 upper = 2.339 for t in ltests: label, expected = t format.setFormat(label) result = format.labelForLowerUpper(lower, upper) self.assertEqual( result, expected, "Label format error {0} => {1}".format(label, result)) range = QgsRendererRangeV2() range.setLowerValue(lower) range.setUpperValue(upper) label = ltests[0][0] format.setFormat(label) result = format.labelForRange(range) self.assertEqual( result, ltests[0][1], "Label for range error {0} => {1}".format(label, result))
def run(self): """Run method that performs all the real work""" #~path = 'C:/Users/Sudhanshu/Downloads/Hivre_Bajar' #~ path = 'C:/Users/Rahul/Desktop/Gondala1' #~ path = 'C:/Users/Rahul/Desktop/BW_new' path = '' debugging = path != '' if debugging: zones_layer = self.iface.addVectorLayer(path + '/Zones.shp', 'Zones', 'ogr') soil_layer = self.iface.addVectorLayer(path + '/Soil.shp', 'Soil Cover', 'ogr') lulc_layer = self.iface.addVectorLayer(path + '/LULC.shp', 'Land-Use-Land-Cover', 'ogr') cadastral_layer = self.iface.addVectorLayer( path + '/Cadastral.shp', 'Cadastral Map', 'ogr') slope_layer = self.iface.addRasterLayer(path + '/Slope.tif', 'Slope') #~ drainage_layer = self.iface.addRasterLayer(path + '/Drainage.shp', 'Drainage', 'ogr') rainfall_csv = path + '/Rainfall.csv' sowing_threshold = 30 crop = 'soyabean' interval_points = [50, 100] monsoon_end_date_index = MONSOON_END_DATE_INDEX else: self.dlg.show() if self.dlg.exec_() == QFileDialog.Rejected: return path = self.dlg.folder_path.text() zones_layer = self.iface.addVectorLayer( self.dlg.zones_layer_filename.text(), 'Zones', 'ogr') soil_layer = self.iface.addVectorLayer( self.dlg.soil_layer_filename.text(), 'Soil Cover', 'ogr') lulc_layer = self.iface.addVectorLayer( self.dlg.lulc_layer_filename.text(), 'Land-Use-Land-Cover', 'ogr') cadastral_layer = self.iface.addVectorLayer( self.dlg.cadastral_layer_filename.text(), 'Cadastral Map', 'ogr') slope_layer = self.iface.addRasterLayer( self.dlg.slope_layer_filename.text(), 'Slope') if self.dlg.drainage_layer_filename.text() != '': drainage_layer = self.iface.addRasterLayer( self.dlg.drainage_layer_filename.text(), 'Drainage', 'ogr') rainfall_csv = self.dlg.rainfall_csv_filename.text() sowing_threshold = self.dlg.sowing_threshold.value() monsoon_end_date_index = self.dlg.monsoon_end.value() + 123 crop = self.dlg.crop_combo_box.currentText() interval_points = [ int( self.dlg.colour_code_intervals_list_widget.item( i).text().split('-')[0]) for i in range( 1, self.dlg.colour_code_intervals_list_widget.count()) ] #~ print path, zones_layer, soil_layer, lulc_layer, cadastral_layer, slope_layer, drainage_layer, rainfall_csv #~ start_qdate = self.dlg.from_date_edit.date() #~ date_with_index_0 = QDate(start_qdate.year(), 6, 1).dayOfYear() #~ start_date_index = start_qdate.dayOfYear() - date_with_index_0 #~ end_qdate = self.dlg.to_date_edit.date() #~ end_date_index = end_qdate.dayOfYear() - date_with_index_0 pointwise_output_csv_filename = '/kharif_model_pointwise_output.csv' zonewise_budget_csv_filename = '/kharif_model_zonewise_budget.csv' zonewise_budget_csv_filename_LU = '/kharif_model_zonewise_LU_budget.csv' zonewise_budget_areawise_csv_filename = '/kharif_model_zonewise_budget_area.csv' cadastral_vulnerability_csv_filename = '/kharif_model_cadastral_vulnerability.csv' model_calculator = KharifModelCalculator(path, zones_layer, soil_layer, lulc_layer, cadastral_layer, slope_layer, rainfall_csv) model_calculator.calculate(crop, pointwise_output_csv_filename, zonewise_budget_csv_filename, zonewise_budget_csv_filename_LU, zonewise_budget_areawise_csv_filename, cadastral_vulnerability_csv_filename, sowing_threshold, monsoon_end_date_index) uri = 'file:///' + path + pointwise_output_csv_filename + '?delimiter=%s&crs=epsg:32643&xField=%s&yField=%s' % ( ',', 'X', 'Y') kharif_model_output_layer = QgsVectorLayer(uri, 'Kharif Model Output', 'delimitedtext') graduated_symbol_renderer_range_list = [] ET_D_max = max([ point.budget.PET_minus_AET_crop_end for point in model_calculator.output_grid_points ]) opacity = 1 intervals_count = self.dlg.colour_code_intervals_list_widget.count() for i in range(intervals_count): percent_interval_start_text, percent_interval_end_text = self.dlg.colour_code_intervals_list_widget.item( i).text().split('-') interval_min = 0 if percent_interval_start_text == '0' else ( int(percent_interval_start_text) * ET_D_max / 100.0 + 0.01) interval_max = (int(percent_interval_end_text) * ET_D_max / 100.0) label = "{0:.2f} - {1:.2f}".format(interval_min, interval_max) colour = QColor( int(255 * (1 - (i + 1.0) / (intervals_count + 1.0))), 0, 0) # +1 done to tackle boundary cases symbol = QgsSymbolV2.defaultSymbol( kharif_model_output_layer.geometryType()) symbol.setColor(colour) symbol.setAlpha(opacity) interval_range = QgsRendererRangeV2(interval_min, interval_max, symbol, label) graduated_symbol_renderer_range_list.append(interval_range) renderer = QgsGraduatedSymbolRendererV2( '', graduated_symbol_renderer_range_list) renderer.setMode(QgsGraduatedSymbolRendererV2.EqualInterval) renderer.setClassAttribute('Crop duration PET-AET') kharif_model_output_layer.setRendererV2(renderer) QgsMapLayerRegistry.instance().addMapLayer(kharif_model_output_layer) QgsVectorFileWriter.writeAsVectorFormat( kharif_model_output_layer, path + '/kharif_et_deficit.shp', "utf-8", None, "ESRI Shapefile") #Dislpaying for long kharif crops if (crop in long_kharif_crops): kharif_model_monsoon_end_output_layer = QgsVectorLayer( uri, 'Kharif Model Monsoon End Output', 'delimitedtext') graduated_symbol_renderer_range_list = [] ET_D_max = max([ point.budget.PET_minus_AET_monsoon_end for point in model_calculator.output_grid_points ]) opacity = 1 intervals_count = self.dlg.colour_code_intervals_list_widget.count( ) geometry_type = kharif_model_monsoon_end_output_layer.geometryType( ) for i in range(intervals_count): percent_interval_start_text, percent_interval_end_text = self.dlg.colour_code_intervals_list_widget.item( i).text().split('-') interval_min = 0 if percent_interval_start_text == '0' else ( int(percent_interval_start_text) * ET_D_max / 100.0 + 0.01) interval_max = (int(percent_interval_end_text) * ET_D_max / 100.0) label = "{0:.2f} - {1:.2f}".format(interval_min, interval_max) colour = QColor( int(255 * (1 - (i + 1.0) / (intervals_count + 1.0))), 0, 0) # +1 done to tackle boundary cases symbol = QgsSymbolV2.defaultSymbol(geometry_type) symbol.setColor(colour) symbol.setAlpha(opacity) interval_range = QgsRendererRangeV2(interval_min, interval_max, symbol, label) graduated_symbol_renderer_range_list.append(interval_range) renderer = QgsGraduatedSymbolRendererV2( '', graduated_symbol_renderer_range_list) renderer.setMode(QgsGraduatedSymbolRendererV2.EqualInterval) renderer.setClassAttribute('Monsoon PET-AET') kharif_model_monsoon_end_output_layer.setRendererV2(renderer) QgsMapLayerRegistry.instance().addMapLayer( kharif_model_monsoon_end_output_layer) QgsVectorFileWriter.writeAsVectorFormat( kharif_model_monsoon_end_output_layer, path + '/kharif_post_monsoon_et_deficit.shp', "utf-8", None, "ESRI Shapefile") self.iface.actionHideAllLayers().trigger() self.iface.legendInterface().setLayerVisible(zones_layer, True) if 'drainage_layer' in locals(): self.iface.legendInterface().setLayerVisible(drainage_layer, True) if (crop in long_kharif_crops): self.iface.legendInterface().setLayerVisible( kharif_model_monsoon_end_output_layer, True) self.iface.legendInterface().setLayerVisible(kharif_model_output_layer, True) self.iface.mapCanvas().setExtent(zones_layer.extent()) self.iface.mapCanvas().mapRenderer().setDestinationCrs( zones_layer.crs()) self.iface.mapCanvas().refresh() if self.dlg.save_image_group_box.isChecked(): QTimer.singleShot( 1000, lambda: self.iface.mapCanvas().saveAsImage( self.dlg.save_image_filename.text()))
def testQgsGraduatedSymbolRendererV2_2(self): """Test QgsGraduatedSymbolRendererV2: Adding /removing/editing classes """ # Create a renderer renderer = QgsGraduatedSymbolRendererV2() symbol = createMarkerSymbol() renderer.setSourceSymbol(symbol.clone()) symbol.setColor(QColor(255, 0, 0)) # Add class without start and end ranges renderer.addClass(symbol.clone()) renderer.addClass(symbol.clone()) renderer.updateRangeLabel(1, 'Second range') renderer.updateRangeLowerValue(1, 10.0) renderer.updateRangeUpperValue(1, 25.0) renderer.updateRangeRenderState(1, False) symbol.setColor(QColor(0, 0, 255)) renderer.updateRangeSymbol(1, symbol.clone()) # Add as a rangeobject symbol.setColor(QColor(0, 255, 0)) range = QgsRendererRangeV2(20.0, 25.5, symbol.clone(), 'Third range', False) renderer.addClassRange(range) # Add class by lower and upper renderer.addClassLowerUpper(25.5, 30.5) # (Update label for sorting tests) renderer.updateRangeLabel(3, 'Another range') self.assertEqual( dumpRangeLabels(renderer.ranges()), '(0.0 - 0.0,Second range,Third range,Another range,)', 'Added ranges labels not correct') self.assertEqual( dumpRangeBreaks(renderer.ranges()), '(0.0000-0.0000,10.0000-25.0000,20.0000-25.5000,25.5000-30.5000,)', 'Added ranges lower/upper values not correct') # Check that clone function works renderer2 = renderer.clone() self.assertEqual(dumpGraduatedRenderer(renderer), dumpGraduatedRenderer(renderer2), "clone function doesn't replicate renderer properly") # Check save and reload from Dom works doc = QDomDocument() element = renderer.save(doc) renderer2 = QgsGraduatedSymbolRendererV2.create(element) self.assertEqual( dumpGraduatedRenderer(renderer), dumpGraduatedRenderer(renderer2), "Save/create from DOM doesn't replicate renderer properly") # Check sorting renderer.sortByLabel() self.assertEqual( dumpRangeList(renderer.ranges(), labelsOnly=True), '(0.0 - 0.0,Another range,Second range,Third range,)', 'sortByLabel not correct') renderer.sortByValue() self.assertEqual( dumpRangeBreaks(renderer.ranges()), '(0.0000-0.0000,10.0000-25.0000,20.0000-25.5000,25.5000-30.5000,)', 'sortByValue not correct') renderer.sortByValue(Qt.DescendingOrder) self.assertEqual( dumpRangeBreaks(renderer.ranges()), '(25.5000-30.5000,20.0000-25.5000,10.0000-25.0000,0.0000-0.0000,)', 'sortByValue descending not correct') # Check deleting renderer.deleteClass(2) self.assertEqual(dumpRangeBreaks(renderer.ranges()), '(25.5000-30.5000,20.0000-25.5000,0.0000-0.0000,)', 'deleteClass not correct') renderer.deleteAllClasses() self.assertEqual(len(renderer.ranges()), 0, "deleteAllClasses didn't delete all")
def makeSymbologyForRange(layer, min, max, title, color): symbol = validatedDefaultSymbol(layer.geometryType()) symbol.setColor(color) range = QgsRendererRangeV2(min, max, symbol, title) return range