Пример #1
0
    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
Пример #2
0
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
Пример #3
0
 *   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)])
Пример #4
0
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)
Пример #5
0
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)