Scripts Python para o QGIS Processing Toolbox

Trend Surface Generation
Smooth Contours
Tred Surface Analysis - experimental
Natural Neighbor Interpolation - dev

Script Python para gerar Superfície de Tendência

Script para gerar superfície de tendência a partir de pontos

Como Instalar o Script:

Salve o código em um arquivo chamado TrendSurfaceAlgorithm.py
No QGIS:
- Vá para Processamento → Caixa de Ferramentas
- Clique no botão Scripts (ícone de pasta)
- Vá para Tools → Add Script from File
- Selecione o arquivo salvo
Ou coloque na pasta de scripts:
- Pasta padrão: C:\Users\[Usuário]\AppData\Roaming\QGIS\QGIS3\profiles\default\processing\scripts\ (Windows)
- Ou ~/.local/share/QGIS/QGIS3/profiles/default/processing/scripts/ (Linux)

Como Usar:

Execute o script através do Processing Toolbox
Parâmetros de entrada:
- Camada de pontos
- Campo com valores Z
- Grau do polinômio (1=linear, 2=quadrático, etc.)
- Tamanho da célula
- Extensão (opcional)
- Arquivo de saída

Funcionalidades:

✅ Suporte a diferentes graus polinomiais
✅ Ajuste por mínimos quadrados
✅ Configuração de resolução espacial
✅ Define SRC automaticamente
✅ Feedback de progresso
✅ Tratamento de erros

O script criará um raster contendo a superfície de tendência baseada nos seus pontos de entrada!

QGIS Algorithm Smooth Contours from Raster

Instalação:

Salve o código em um arquivo chamado smooth_contours.py
No QGIS:
- Vá para Processamento > Caixa de Ferramentas
- Clique no botão Scripts (ícone de pasta com +)
- Selecione Adicionar Script do Arquivo
- Navegue até o arquivo smooth_contours.py

Uso:

Abra a Caixa de Ferramentas de Processamento (Processamento > Caixa de Ferramentas)
Encontre o algoritmo em Scripts > Custom > Contornos Suaves a partir de Raster
Parâmetros disponíveis:
- Raster de entrada: Seu raster de elevação
- Intervalo entre curvas: Espaçamento entre as curvas de nível
- Método de suavização:
  - Gaussian: Suavização mais natural
  - Median: Preserva bordas melhor
  - Mean: Suavização uniforme
- Grau de suavização: Número de iterações (1-10)
- Tolerância de simplificação: Simplifica a geometria final

Vantagens sobre as ferramentas nativas:

✅ Contornos suaves sem serrilhados
✅ Múltiplos métodos de suavização
✅ Controle fino sobre o nível de suavização
✅ Preserva metadados das curvas de nível
✅ Integração completa com o Processing Toolbox

O algoritmo combina suavização do raster original com suavização vetorial pós-processamento para obter resultados muito mais suaves que as ferramentas padrão do QGIS.

Principais correções feitas:

Corrigido o erro do noDataValue:
- Substituído band_stats.noDataValue por raster_layer.dataProvider().sourceNoDataValue(1)
Melhor tratamento de erros:
- Verificação se a camada de contornos é válida
- Verificação se foram geradas feições
- Melhor feedback para o usuário
Progresso corrigido:
- Cálculo correto da porcentagem de progresso
Limpeza de arquivos temporários:
- Verificação se os arquivos existem antes de tentar remover
Adicionada documentação:
- shortHelpString() com explicações detalhadas

Como usar a versão corrigida:

Salve o código corrigido em um arquivo .py
Adicione ao Processing Toolbox como antes
Execute o algoritmo - agora deve funcionar sem erros

O algoritmo agora irá:

✅ Gerar contornos suaves sem serrilhados
✅ Lidar corretamente com valores NoData
✅ Fornecer feedback informativo durante o processamento
✅ Limpar arquivos temporários automaticamente

Estilo para Camada de Contornos (QML)

Aqui está um estilo completo para QGIS que diferencia linhas mestras (index contours) das linhas normais, incluindo simbologia e rótulos:

1. Como Aplicar o Estilo:

Método 1: Salvar como Arquivo QML

Salve o código acima em um arquivo chamado contornos_suaves.qml
No QGIS: Clique direito na camada > Propriedades > Estilo > Carregar Estilo
Selecione o arquivo .qml salvo

Método 2: Configurar Manualmente

Simbologia:

Vá para Propriedades da Camada > Simbologia
Selecione Renderizador baseado em regras
Adicione as regras:

Regra 1 - Linhas Mestras (100 em 100):

Filtro: "elevation" % 100 = 0
- Cor: Preto (#000000)
- Espessura: 0.66 mm
- Estilo: Linha sólida

Regra 2 - Linhas Intermediárias (50 em 50):

Filtro: "elevation" % 50 = 0 AND "elevation" % 100 != 0
- Cor: Preto (#000000)  
- Espessura: 0.46 mm
- Estilo: Linha sólida

Regra 3 - Linhas Normais:

Filtro: ELSE
- Cor: Cinza escuro (#646464)
- Espessura: 0.26 mm
- Estilo: Linha sólida

Rótulos:

Vá para Propriedades da Camada > Rótulos
Selecione Rotulação baseada em regras
Configure as regras:

Regra 1 - Rótulos Linhas Mestras:

Filtro: "elevation" % 100 = 0
Expressão: format_number("elevation",0) || ' m'
Fonte: Arial, Negrito, 10pt
Buffer: Branco, 1.5mm
Posicionamento: Ao longo da linha

Regra 2 - Rótulos Linhas Intermediárias (Opcional):

Filtro: "elevation" % 50 = 0 AND "elevation" % 100 != 0
Expressão: format_number("elevation",0)
Fonte: Arial, Normal, 8pt
Buffer: Branco, 1.0mm

2. Características do Estilo:

Linhas Mestras: Mais espessas (0.66mm), pretas, com rótulos em negrito
Linhas Intermediárias: Espessura média (0.46mm), pretas, rótulos opcionais
Linhas Normais: Mais finas (0.26mm), cinza, sem rótulos
Rótulos: Com buffer branco para melhor legibilidade
Hierarquia visual clara para fácil interpretação do relevo

3. Personalização:

Você pode ajustar facilmente:

Intervalos: Modifique os filtros (100, 50) conforme seu intervalo de contorno
Cores: Altere as cores RGB nos símbolos
Espessuras: Ajuste as espessuras das linhas
Fontes: Modifique família, tamanho e estilo das fontes

Este estilo criará uma visualização profissional e fácil de interpretar para suas curvas de nível!

Polynomial Regression with Least Squares

1. Understanding Polynomial Regression

What is Polynomial Regression?

Polynomial regression extends linear regression to model nonlinear relationships by adding polynomial terms:

Linear Regression:

z = β₀ + β₁x + β₂y

Quadratic Regression:

z = β₀ + β₁x + β₂y + β₃x² + β₄xy + β₅y²

Cubic Regression:

z = β₀ + β₁x + β₂y + β₃x² + β₄xy + β₅y² + β₆x³ + β₇x²y + β₈xy² + β₉y³

2. Mathematical Foundation

Least Squares Method

The goal is to minimize the sum of squared residuals:

min Σ(z_i - ž_i)²

Where:

z_i = observed value at point i
ž_i = predicted value from polynomial

Matrix Formulation

A · β = Z

Where:

A = Design matrix of polynomial terms
β = Coefficient vector (what we solve for)
Z = Observed values vector

Solution using Normal Equations

β = (AᵀA)⁻¹AᵀZ

3. Step-by-Step Algorithm

Step 1: Data Preparation

# Input data: x, y coordinates and z values
x = [x₁, x₂, ..., xₙ]
y = [y₁, y₂, ..., yₙ]  
z = [z₁, z₂, ..., zₙ]

Step 2: Design Matrix Construction

For degree 2 polynomial:

# Each row: [1, x, y, x², xy, y²]
A = [
    [1, x₁, y₁, x₁², x₁y₁, y₁²],
    [1, x₂, y₂, x₂², x₂y₂, y₂²],
    ...
    [1, xₙ, yₙ, xₙ², xₙyₙ, yₙ²]
]

Step 3: Solve Least Squares

# Using numpy's least squares solver
coefficients = np.linalg.lstsq(A, z, rcond=None)[0]

Step 4: Surface Evaluation

def evaluate_polynomial(x, y, coeffs, degree):
    value = 0
    idx = 0
    for d in range(degree + 1):
        for j in range(d + 1):
            value += coeffs[idx] * (x ** (d - j)) * (y ** j)
            idx += 1
    return value

4. Practical Example

Sample Data:

Point	X	Y	Z (Elevation)
1	0	0	100
2	10	0	110
3	0	10	105
4	10	10	115

Linear Surface (Degree 1):

Design Matrix A:
[[1, 0, 0],
 [1, 10, 0], 
 [1, 0, 10],
 [1, 10, 10]]
 
Solving: A·β = [100, 110, 105, 115]

Result:

z = 100 + 1.0*x + 0.5*y

5. Choosing Polynomial Degree

Degree 1 - Linear:

Good for simple trends
3 coefficients
Planar surface

Degree 2 - Quadratic:

Captures curvature
6 coefficients
Can model hills/valleys

Degree 3 - Cubic:

Complex surfaces
10 coefficients
Risk of overfitting

6. Interpretation of Results

Residual Analysis:

residuals = z_observed - z_predicted
RMSE = np.sqrt(np.mean(residuals**2))

Goodness of Fit:

R²: Proportion of variance explained
RMSE: Average prediction error
Visual inspection: Check residual patterns

7. Applications in GIS

Topographic Analysis:

Regional slope detection
Geological trend identification
Climate pattern analysis

Environmental Modeling:

Pollution gradient mapping
Temperature surface generation
Precipitation trend analysis

8. Advantages and Limitations

Advantages:

Simple mathematical foundation
Computationally efficient
Easy to interpret coefficients
Flexible for different complexities

Limitations:

Sensitive to outliers
Assumes global trend (no local variations)
Can overfit with high degrees
Extrapolation risks

9. Validation Methods

Cross-Validation:

# Split data into training and testing
train_mask = np.random.choice([True, False], size=len(z), p=[0.7, 0.3])
train_A, test_A = A[train_mask], A[~train_mask]
train_z, test_z = z[train_mask], z[~train_mask]

Residual Mapping:

Create residual raster (observed - predicted)
Check for spatial patterns
Identify areas of poor fit

This tutorial provides both the theoretical foundation and practical implementation for polynomial trend surface analysis using least squares regression!

Script de interpolação por Vizinhos Naturais para QGIS Processing Toolbox

Para usar este script:

Salvar o arquivo: Salve o código como natural_neighbor_interpolation.py na pasta de scripts do Processing:
- Windows: C:\Users\[usuário]\AppData\Roaming\QGIS\QGIS3\profiles\default\processing\scripts\
- Linux: ~/.local/share/QGIS/QGIS3/profiles/default/processing/scripts/
- macOS: ~/Library/Application Support/QGIS/QGIS3/profiles/default/processing/scripts/
Reiniciar o QGIS: Reinicie o QGIS para carregar o novo script.
Acessar o script: Vá para Processing → Toolbox e procure por "Interpolação por Vizinhos Naturais" na pasta "Scripts".

Versão alternativa usando SAGA GIS (mais precisa para Natural Neighbor):

Se você tiver o SAGA GIS instalado, pode usar esta versão alternativa do script

Características do script:

Interface amigável com todos os parâmetros necessários
Feedback de progresso durante a execução
Validação de parâmetros
Documentação integrada
Compatível com o framework de processamento do QGIS

O script criará um raster interpolado usando o método de vizinhos naturais, que é particularmente útil para dados pontuais irregulares e produz superfícies suaves sem necessidade de ajuste de parâmetros complexos.

QGIS Processing Toolbox Algorithm