def validate_attributes(self, layers, combo, index, attributes_name):
name = combo.itemText(index)
layer = find_one_layer_by_name(layers, name)
attributes = load_config()['vulnerabilidade'][attributes_name]
fields = [str(field.name()) for field in layer.pendingFields()]
for attr in attributes:
if str(attr) not in fields:
self.logger.error('Layer Attributes "{}" error on validation attributes...'.format(str(attr)))
return 'Erro na validacao do atributo "{}".'.format(str(attr)), None
break
return layer
class RiscoFogo(object):
cqfs_config = load_config()
logger = logging.getLogger(PLUGIN_RISCO_FOGO)
proj4 = cqfs_config['global']['crs_proj4']
params = cqfs_config[PLUGIN_RISCO_FOGO]
def __init__(self, dlg, vectors_name, rasters_name):
self.__qt = QtHandler()
self.__combo_risco_fogo_raster_propagacao = dlg.combo_risco_fogo_raster_propagacao
self.__combo_risco_fogo_grid_ignicao = dlg.combo_risco_fogo_grid_ignicao
self.__line_saida_risco_tecnico = dlg.line_saida_risco_tecnico
self.__btn_saida_risco_tecnico = dlg.btn_saida_risco_tecnico
QtHandler.set_combobox(self.__combo_risco_fogo_raster_propagacao,
rasters_name, self.on_raster_propagacao_change)
QtHandler.set_combobox(self.__combo_risco_fogo_grid_ignicao,
vectors_name, self.on_grid_ignicao_change)
combo = {
PLUGIN_RISCO_FOGO_PROPAGACAO:
self.__combo_risco_fogo_raster_propagacao
}
self.__qt.init_combobox(rasters_name, **combo)
def destroy(self):
self.__combo_risco_fogo_raster_propagacao.clear()
self.__combo_risco_fogo_grid_ignicao.clear()
self.__line_saida_risco_tecnico.clear()
self.__qt.clear_combobox()
self.__qt = None
self.__combo_risco_fogo_raster_propagacao = None
self.__combo_risco_fogo_grid_ignicao = None
self.__line_saida_risco_tecnico = None
self.__btn_saida_risco_tecnico = None
@property
def combo_name_by_layer_index(self):
return self.__qt.combo_name_by_layer_index
def on_raster_propagacao_change(self, combo, index):
self.__qt.on_combobox_change(PLUGIN_RISCO_FOGO_PROPAGACAO, combo,
index)
@staticmethod
def on_grid_ignicao_change(combo, index):
if index == 0:
return
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
"""
import logging
import math
from PyQt4.QtCore import QVariant
from cqfs_config import load_config, tmp_filename_without_extension
from qgis._core import QgsField
from layer_util import set_layer_style, has_attributes
from ..src.qt_handler import QtHandler
__logger = logging.getLogger('calc_operations')
__config = load_config()
def calc(plugin_name, progress, layer):
__logger.info('Start calc')
params = __config[plugin_name]
__logger.info(layer)
fields = [str(field.name()) for field in layer.pendingFields()]
pr = layer.dataProvider()
if params['att_rup_ff'] not in fields:
pr.addAttributes([QgsField(params['att_rup_ff'], QVariant.Double)])
class Criticidade(object):
logger = logging.getLogger(PLUGIN_CRITICIDADE)
cqfs_config = load_config()
params = cqfs_config[PLUGIN_CRITICIDADE]
proj4 = cqfs_config['global']['crs_proj4']
def __init__(self, rasters_name, vectors_name, combo_vulnerabilidade,
combo_risco_fogo):
self.logger.error('Init criticidade')
self.__qt = QtHandler()
self.__qt.init_combobox(rasters_name, risco_fogo=combo_risco_fogo)
QtHandler.set_combobox(combo_vulnerabilidade, vectors_name,
self.on_vulnerabilidade_change)
QtHandler.set_combobox(combo_risco_fogo, rasters_name,
self.on_risco_fogo_change)
self.__combo_vulnerabilidade = combo_vulnerabilidade
self.__combo_risco_fogo = combo_risco_fogo
def validate_vulnerabilidade(self, layers, combo_vulnerabilidade):
vulnerabilidade_index = combo_vulnerabilidade.currentIndex()
if combo_vulnerabilidade <= 0:
return 'Selecione o shape de Vulnerabilidade.', None
# validação de atributos
layer_vulnerabilidade = self.validate_attributes(
layers, combo_vulnerabilidade, vulnerabilidade_index,
'attributes_vulnerabilidade')
return None, layer_vulnerabilidade
def validate_attributes(self, layers, combo, index, attributes_name):
name = combo.itemText(index)
layer = find_one_layer_by_name(layers, name)
attributes = self.params[attributes_name]
fields = [str(field.name()) for field in layer.pendingFields()]
for attr in attributes:
if str(attr) not in fields:
self.logger.error(
'Layer Attributes "{}" error on validation attributes...'.
format(str(attr)))
return 'Erro na validacao de atributos.', None
return layer
def destroy(self):
self.__combo_vulnerabilidade.clear()
self.__combo_risco_fogo.clear()
self.__qt.clear_combobox()
self.__qt = None
self.__combo_vulnerabilidade = None
self.__combo_risco_fogo = None
@property
def combo_name_by_layer_index(self):
return self.__qt.combo_name_by_layer_index
def generate_zonal(self, vao, risco_fogo, output):
zs = ZonalStatisticsNewLayer(vao.source(),
risco_fogo.source(),
output,
operations=('max', ),
fields_alias=('CRIT', ))
zs.perform()
output_layer = QgsVectorLayer(output, 'risco_zs', 'ogr')
QgsMapLayerRegistry.instance().addMapLayers([output_layer])
return None, output_layer
def classify_risco(self, layer):
_, bar = QtHandler.progress_dialog(label='Classifying Risk...')
fields = [str(field.name()) for field in layer.pendingFields()]
pr = layer.dataProvider()
bar.setValue(20)
if self.params['att_cls_criticidade'] not in fields:
pr.addAttributes([
QgsField(self.params['att_cls_criticidade'], QVariant.String)
])
layer.updateFields()
bar.setValue(50)
layer.startEditing()
for feature in layer.getFeatures():
criticidade = feature[self.params['att_criticidade']]
classificacao = self.classify(criticidade)
layer.changeAttributeValue(
feature.id(),
layer.fieldNameIndex(self.params['att_cls_criticidade']),
classificacao)
layer.commitChanges()
bar.setValue(100)
return None, layer
def classify(self, criticidade):
if criticidade <= 0.2:
return self.params['classif_muito_baixa']
elif 0.2 < criticidade < 0.4:
return self.params['classif_baixa']
elif 0.4 < criticidade < 0.6:
return self.params['classif_media']
elif 0.6 < criticidade < 0.8:
return self.params['classif_alta']
elif criticidade >= 0.8:
return self.params['classif_muito_alta']
@staticmethod
def on_vulnerabilidade_change(combo, index):
if index == 0:
return
def on_risco_fogo_change(self, combo, index):
self.__qt.on_combobox_change('risco_fogo', combo, index)
class Vulnerabilidade(object):
logger = logging.getLogger(PLUGIN_VULNERABILIDADE)
cqfs_config = load_config()
params = cqfs_config[PLUGIN_VULNERABILIDADE]
proj4 = cqfs_config['global']['crs_proj4']
def __init__(self, vectors_vao_name, vectors_name, combo_vao, combo_ponto_critico, combo_torre):
self.logger.error('Init vulnerabilidade')
self.__qt = QtHandler()
self.__combo_vao = combo_vao
self.__combo_ponto_critico = combo_ponto_critico
self.__combo_torre = combo_torre
self.__init_combobox(vectors_name)
QtHandler.set_combobox(combo_vao, vectors_vao_name, self.on_vao_change)
QtHandler.set_combobox(combo_ponto_critico, vectors_name, self.on_ponto_critico_change)
QtHandler.set_combobox(combo_torre, vectors_name, self.on_torre_change)
def destroy(self):
self.__combo_vao.clear()
self.__combo_ponto_critico.clear()
self.__combo_torre.clear()
self.__qt.clear_combobox()
self.__qt = None
self.__combo_vao = None
self.__combo_ponto_critico = None
self.__combo_torre = None
def validate(self, layers, combo_vao, combo_ponto_critico, combo_torres):
vao_index = combo_vao.currentIndex()
ponto_critico_index = combo_ponto_critico.currentIndex()
torres_index = combo_torres.currentIndex()
if vao_index <= 0:
return 'Selecione o vão.', None
if ponto_critico_index <= 0:
return 'Selecione o ponto critico.', None
if torres_index <= 0:
return 'Selecione as torres.', None
# validação de atributos
layer_vao = self.validate_attributes(layers, combo_vao, vao_index, 'attributes_vao')
layer_pc = self.validate_attributes(layers, combo_ponto_critico, ponto_critico_index, 'attributes_ponto_critico')
layer_torres = self.validate_attributes(layers, combo_torres, torres_index, 'attributes_torres')
self.verify_group_attribute(layer_vao)
self.verify_group_attribute(layer_torres)
validate_vectors(layers, combo_vao, self.proj4)
validate_vectors(layers, combo_ponto_critico, self.proj4)
validate_vectors(layers, combo_torres, self.proj4)
prov = layer_vao.dataProvider()
attr_type = prov.fields().field(self.params['att_vao_id']).type()
if attr_type not in (QVariant.Int, QVariant.Double):
return 'A coluna "{}" deve ser numerica.'.format(self.params['att_vao_id']), None, None, None
return None, layer_vao, layer_pc, layer_torres
def validate_attributes(self, layers, combo, index, attributes_name):
name = combo.itemText(index)
layer = find_one_layer_by_name(layers, name)
attributes = load_config()['vulnerabilidade'][attributes_name]
fields = [str(field.name()) for field in layer.pendingFields()]
for attr in attributes:
if str(attr) not in fields:
self.logger.error('Layer Attributes "{}" error on validation attributes...'.format(str(attr)))
return 'Erro na validacao do atributo "{}".'.format(str(attr)), None
break
return layer
def verify_group_attribute(self, layer):
fields = [str(field.name()) for field in layer.pendingFields()]
grupo = self.params['att_grupo']
if grupo not in fields:
pr = layer.dataProvider()
pr.addAttributes([QgsField(self.params['att_grupo'], QVariant.Int)])
layer.updateFields()
return
def __init_combobox(self, vectors_name):
combo = {
PLUGIN_VULNERABILIDADE_PC: self.__combo_ponto_critico,
PLUGIN_VULNERABILIDADE_TORRE: self.__combo_torre,
}
self.__qt.init_combobox(vectors_name, **combo)
def on_vao_change(self, combo, index):
if index == 0:
return
def on_ponto_critico_change(self, combo, index):
self.__qt.on_combobox_change(PLUGIN_VULNERABILIDADE_PC, combo, index)
def on_torre_change(self, combo, index):
self.__qt.on_combobox_change(PLUGIN_VULNERABILIDADE_TORRE, combo, index)