No QGIS, muitas operações devem ser aplicadas apenas a uma parte dos dados: um conjunto específico de feições selecionadas pelo usuário.
Neste artigo, veremos como um plugin QGIS pode detectar, verificar e processar apenas as feições selecionadas, sem correr o risco de modificar toda a camada por engano.
O objetivo é duplo: tornar os processamentos mais seguros e respeitar a intenção do usuário, mantendo um código simples e acessível para iniciantes.
Modificar uma camada no QGIS pode parecer arriscado, especialmente para quem está começando a desenvolver plugins. O guia Modificar uma Camada QGIS sem Colocá-la em Risco explica de forma simples como utilizar o modo de edição, confirmar ou cancelar alterações e atualizar camadas e atributos com segurança. Compreender esses conceitos ajudará você a proteger seus dados enquanto desenvolve plugins realmente úteis.
Por que trabalhar apenas com as feições selecionadas?
No QGIS, os usuários raramente selecionam feições por acaso.
Uma seleção normalmente expressa uma intenção muito clara:
“Quero trabalhar com estas feições, e não com as outras.”
Um plugin que ignora a seleção atual e processa toda a camada:
- pode produzir erros graves;
- reduz a confiança do usuário;
- torna-se arriscado de utilizar.
Como regra geral, um plugin bem projetado deve respeitar a seleção ativa.
Como o QGIS gerencia seleções de feições
No QGIS:
- a seleção pertence à camada;
- é temporária e pode mudar a qualquer momento;
- pode ser acessada diretamente pela API PyQGIS.
A qualquer momento, uma camada vetorial sabe:
- quantas feições estão selecionadas;
- quais feições estão selecionadas.
Isso torna a seleção uma forma simples e confiável de trabalhar com um subconjunto dos dados.
Recuperando a camada ativa
Na maioria dos plugins, o primeiro passo consiste em recuperar a camada atualmente ativa.
layer = iface.activeLayer()
A primeira regra de segurança é simples:
if not layer:
return
Sem uma camada ativa, nenhuma ação deve ser executada.
Verificando se existem feições selecionadas
Antes de iniciar qualquer processamento, o plugin deve verificar se o usuário realmente selecionou alguma coisa.
selected_features = layer.selectedFeatures()
if not selected_features:
# nenhuma feição selecionada
return
Nesse momento, o plugin já sabe se deve:
- continuar o processamento;
- ou encerrar a operação de forma segura.
Essa simples verificação evita muitos erros de utilização.
Processando as feições selecionadas
O método selectedFeatures() retorna uma lista de objetos QgsFeature.
Portanto, é possível percorrê-las facilmente:
for feature in selected_features:
# processar cada feição
Cada feição contém:
- seus atributos;
- sua geometria;
- seu identificador único.
Tudo o que o plugin precisa para executar operações específicas sobre os dados selecionados.
Um exemplo simples: lendo um atributo
Depois de obter as feições selecionadas, você pode acessar seus atributos da mesma forma que faria com qualquer outro objeto QgsFeature.
Por exemplo:
for feature in selected_features:
value = feature[“population”]
Neste exemplo, o plugin lê o valor do campo population para cada feição selecionada.
Se o campo não existir, ocorrerá um erro.
Por isso, é importante verificar previamente a estrutura da camada. Um plugin nunca deve presumir que um determinado campo estará sempre presente.
Modificando atributos com segurança
Para modificar feições selecionadas, a camada precisa estar em modo de edição.
Antes de realizar alterações, é recomendável verificar se a edição já está ativa.
if not layer.isEditable():
layer.startEditing()
Em seguida, as feições podem ser atualizadas:
for feature in selected_features:
feature[“status”] = “processed”
layer.updateFeature(feature)
Por fim, as alterações devem ser gravadas:
layer.commitChanges()
Um plugin nunca deve modificar dados silenciosamente sem que o usuário saiba.
Mais adiante nesta série veremos como solicitar confirmação antes de salvar as alterações.
Seleção ativa ≠ filtro ≠ camada temporária
O QGIS oferece diferentes maneiras de trabalhar com um subconjunto dos dados.
Embora possam parecer semelhantes visualmente, esses mecanismos se comportam de forma muito diferente dentro de um plugin.
Compreender essas diferenças é essencial para desenvolver ferramentas confiáveis.
Seleção ativa
A seleção ativa:
- pertence à camada;
- é destacada visualmente;
- pode ser acessada através de
selectedFeatures(); - muda sempre que o usuário altera a seleção.
Este é o mecanismo mais seguro e explícito para a maioria dos plugins.
Filtro de camada
Um filtro:
- oculta as feições que não atendem a uma condição;
- faz a camada parecer menor;
- influencia apenas o que o usuário vê.
Entretanto, salvo precauções específicas, um plugin ainda pode acessar feições ocultas pelo filtro.
Um plugin mal projetado pode modificar feições invisíveis para o usuário.
Camada temporária
Uma camada temporária:
- normalmente é criada por uma ferramenta de processamento;
- contém uma cópia ou subconjunto dos dados originais;
- é independente da camada de origem;
- pode desaparecer quando o projeto é fechado.
Camadas temporárias são excelentes para testes, visualização e análises intermediárias, mas nem sempre são adequadas para modificar os dados originais.
O que você deve lembrar
Esses três conceitos são fundamentalmente diferentes:
- Seleção = intenção explícita do usuário
- Filtro = visão parcial dos dados
- Camada temporária = cópia de trabalho
Na maioria dos plugins voltados para processos de negócio, a seleção ativa é o melhor ponto de partida.
E se nenhuma feição estiver selecionada?
Mais cedo ou mais tarde, todo desenvolvedor de plugins enfrenta a mesma situação:
O usuário executa a ferramenta sem selecionar nenhuma feição.
O que o plugin deve fazer?
Existem duas abordagens comuns.
Opção 1 – Bloquear a ação
A solução mais segura consiste em interromper o processamento e informar o usuário.
Por exemplo:
Selecione pelo menos uma feição antes de executar esta ferramenta.
Essa abordagem evita ambiguidades e previne alterações acidentais.
Na maioria dos casos, esta é a opção mais segura.
Opção 2 – Oferecer uma alternativa
Outra possibilidade consiste em perguntar ao usuário o que ele deseja fazer.
Por exemplo:
Nenhuma feição está selecionada. Deseja aplicar esta operação a toda a camada?
Essa abordagem oferece mais flexibilidade sem retirar o controle do usuário.
O importante é que o plugin nunca tome essa decisão sozinho.
O usuário deve sempre ter a palavra final.
Casos de uso típicos
Trabalhar apenas com feições selecionadas é essencial para muitas tarefas SIG.
Por exemplo:
- recalcular um atributo para um subconjunto de feições;
- corrigir geometrias específicas;
- aplicar regras de negócio a um grupo específico de objetos;
- preparar dados antes de uma exportação;
- validar registros específicos.
Na prática, uma grande parte dos plugins profissionais deveria funcionar dessa forma.
Os usuários esperam que a ferramenta atue apenas sobre os elementos que selecionaram explicitamente.
Por que isso é importante?
Respeitar a seleção ativa não é apenas um detalhe técnico.
É um princípio de design.
Uma seleção representa uma ação explícita realizada pelo usuário.
Ignorá-la frequentemente gera confusão, resultados inesperados e perda de confiança na ferramenta.
Por outro lado, um plugin que respeita a seleção ativa comporta-se de maneira previsível e profissional.
Pontos principais para lembrar
Antes de prosseguir, lembre-se destas ideias essenciais:
- Uma seleção representa a intenção do usuário.
- Um plugin bem projetado deve respeitar essa intenção.
- O código necessário é simples e fácil de compreender.
- A segurança resulta de boas decisões de projeto, não da complexidade do código.
Muitos iniciantes acreditam que tornar um plugin mais seguro exige programação avançada.
Na realidade, a melhor proteção costuma vir de algumas verificações simples realizadas no momento certo.
O que você aprendeu
Ao final deste artigo, você agora sabe:
- como recuperar a camada ativa;
- como detectar feições selecionadas;
- como processar apenas as feições selecionadas;
- como modificar feições selecionadas com segurança;
- por que seleção, filtro e camada temporária são conceitos diferentes.
Seu plugin agora pode trabalhar sobre um subconjunto específico de dados, em vez de processar toda a camada indiscriminadamente.
Este é um passo importante rumo ao desenvolvimento de plugins QGIS mais profissionais e confiáveis.
E no próximo artigo?
No próximo artigo, veremos um tema diretamente relacionado:
como modificar feições sem colocar os dados em risco.
Aprenderemos a:
- trabalhar com segurança no modo de edição;
- confirmar ou cancelar alterações;
- proteger os dados dos usuários;
- desenvolver plugins nos quais os usuários possam confiar.
Um plugin útil não é apenas aquele que executa corretamente uma tarefa, mas também aquele que protege os dados que modifica.
