landuse-intensity-analysis

Name	landuse-intensity-analysis JSON
Version	2.0.0a2 JSON
	download
home_page	None
Summary	Modernized Python library for scientifically rigorous land use change analysis with intelligent auto-detection, comprehensive customization, and streamlined processing pipeline. Features automatic year detection from filenames and complete configuration framework.
upload_time	2025-08-29 18:29:54
maintainer	None
docs_url	None
author	None
requires_python	>=3.8
license	None
keywords	land-use intensity-analysis pontius aldwaik remote-sensing gis land-change spatial-analysis environmental-science
VCS
bugtrack_url
requirements	No requirements were recorded.
Travis-CI	No Travis.
coveralls test coverage	No coveralls.

            # 🌍 Land Use Intensity Analysis

[![PyPI version](https://badge.fury.io/py/landuse-intensity-analysis.svg)](https://pypi.org/project/landuse-intensity-analysis/)
[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

> **Biblioteca Python completa para análise científica de mudanças no uso da terra usando a metodologia de análise de intensidade Pontius-Aldwaik**

---

## 📋 Sumário

- [🚀 Instalação Rápida](#-instalação-rápida)
- [🎯 Guia para Iniciantes](#-guia-para-iniciantes)
- [📊 Como Gerar Gráficos](#-como-gerar-gráficos)
- [🔬 Análise Avançada](#-análise-avançada)
- [📚 Referências](#-referências)

---

## 🚀 Instalação Rápida

```bash
pip install landuse-intensity-analysis
```

**Verificar instalação:**

```python
import landuse_intensity as lui
print("✅ Instalação bem-sucedida!")
```

---

## 🎯 Guia para Iniciantes

### Primeiro Passo: Analisar Mudanças no Uso da Terra

Vamos começar com um exemplo simples usando dados de demonstração:

```python
import landuse_intensity as lui
import numpy as np

# 1. Carregar dados de exemplo
print("📊 Carregando dados de exemplo...")
raster_t1, raster_t2 = lui.demo_landscape()

print(f"Raster 1 (Tempo 1): {raster_t1.shape}")
print(f"Raster 2 (Tempo 2): {raster_t2.shape}")

# 2. Criar tabela de contingência
print("\n🔄 Criando tabela de contingência...")
ct = lui.ContingencyTable.from_rasters(
    raster_t1, raster_t2,
    labels1=['Floresta', 'Agricultura', 'Urbano', 'Água'],
    labels2=['Floresta', 'Agricultura', 'Urbano', 'Água']
)

print("Tabela de contingência criada:")
print(ct.table)

# 3. Análise básica
print(f"\n📈 Estatísticas básicas:")
print(f"Área total: {ct.total_area} pixels")
print(f"Área que mudou: {ct.total_change} pixels ({ct.total_change/ct.total_area*100:.1f}%)")
print(f"Área que permaneceu igual: {ct.persistence} pixels ({ct.persistence/ct.total_area*100:.1f}%)")
```

**Saída esperada:**

```text
📊 Carregando dados de exemplo...
Raster 1 (Tempo 1): (100, 100)
Raster 2 (Tempo 2): (100, 100)

🔄 Criando tabela de contingência...
Tabela de contingência criada:
            Floresta  Agricultura  Urbano  Água
Floresta          450           30      10     5
Agricultura        25          380      15     0
Urbano              5           20     360     0
Água                0            0       0   100

📈 Estatísticas básicas:
Área total: 10000 pixels
Área que mudou: 110 pixels (1.1%)
Área que permaneceu igual: 9890 pixels (98.9%)
```

---

## 📊 Como Gerar Gráficos

### 🎨 Módulos de Visualização Disponíveis

A biblioteca possui **5 módulos especializados** para diferentes tipos de gráficos:

| Módulo | Tipo de Gráfico | Uso Principal |
|--------|----------------|---------------|
| `sankey_visualization` | Diagramas Sankey | Transições entre classes |
| `matrix_visualization` | Matrizes e mapas de calor | Matrizes de transição |
| `bar_chart_visualization` | Gráficos de barras | Análise de áreas e mudanças |
| `statistical_visualization` | Gráficos estatísticos | Análise de desempenho |
| `visualization_utils` | Utilitários | Funções auxiliares |

### 📈 1. Diagrama Sankey (Transições)

**Para visualizar como as classes de uso da terra se transformam:**

```python
from landuse_intensity.sankey_visualization import plot_single_step_sankey

# Criar diagrama Sankey interativo
files = plot_single_step_sankey(
    contingency_data=ct.table,           # Dados da tabela de contingência
    output_dir="outputs",                # Pasta para salvar
    filename="transicoes_sankey",        # Nome do arquivo
    title="Transições no Uso da Terra",  # Título do gráfico
    width=1000,                          # Largura em pixels
    height=600,                          # Altura em pixels
    min_flow=5,                          # Fluxo mínimo para mostrar
    export_formats=['html', 'png']       # Formatos de exportação
)

print("✅ Arquivos gerados:")
for fmt, path in files.items():
    print(f"  {fmt.upper()}: {path}")
```

**Resultado:** Arquivo `outputs/transicoes_sankey.html` com diagrama interativo

### 🔥 2. Mapa de Calor da Matriz de Transição

**Para visualizar a intensidade das transições:**

```python
from landuse_intensity.matrix_visualization import plot_transition_matrix_heatmap

# Criar mapa de calor
fig = plot_transition_matrix_heatmap(
    tabulation_matrix=ct.table,          # Matriz de transição
    filename="matriz_transicao",         # Nome do arquivo
    output_dir="outputs",                # Pasta de saída
    title="Matriz de Transição de Uso da Terra",
    figsize=(10, 8),                     # Tamanho da figura
    cmap="YlOrRd",                       # Paleta de cores
    annot=True,                          # Mostrar valores
    fmt=".1f",                           # Formato dos números
    show_percentages=False               # Mostrar em unidades absolutas
)

print("✅ Mapa de calor salvo em: outputs/matriz_transicao.png")
```

### 📊 3. Gráfico de Barras (Áreas por Classe)

**Para comparar áreas de cada classe de uso da terra:**

```python
import pandas as pd
from landuse_intensity.bar_chart_visualization import plot_barplot_lulc

# Preparar dados para o gráfico
area_data = []
for class_name in ct.table.index:
    area = ct.table.loc[class_name].sum()
    area_data.append({
        'class': class_name,
        'area': area,
        'time_period': 'Tempo 1'
    })

for class_name in ct.table.columns:
    area = ct.table[class_name].sum()
    area_data.append({
        'class': class_name,
        'area': area,
        'time_period': 'Tempo 2'
    })

df_areas = pd.DataFrame(area_data)

# Criar gráfico de barras
fig = plot_barplot_lulc(
    data=df_areas,
    filename="areas_classes",
    output_dir="outputs",
    title="Áreas por Classe de Uso da Terra",
    x_col="class",
    y_col="area",
    time_col="time_period",              # Para comparar períodos
    figsize=(12, 6),
    color_palette="Set2",
    scientific_style=True,
    show_values=True
)

print("✅ Gráfico de barras salvo em: outputs/areas_classes.png")
```

### 📈 4. Análise de Ganhos e Perdas

**Para visualizar quais classes ganharam ou perderam área:**

```python
from landuse_intensity.bar_chart_visualization import plot_gain_loss_analysis

# Preparar dados de ganho/perda
gain_loss_data = []
classes = list(set(ct.table.index) | set(ct.table.columns))

for class_name in classes:
    # Calcular ganhos (entradas)
    if class_name in ct.table.columns:
        gain = ct.table[class_name].sum() - ct.table.loc[class_name, class_name] if class_name in ct.table.index else ct.table[class_name].sum()
    else:
        gain = 0

    # Calcular perdas (saídas)
    if class_name in ct.table.index:
        loss = ct.table.loc[class_name].sum() - ct.table.loc[class_name, class_name] if class_name in ct.table.columns else ct.table.loc[class_name].sum()
    else:
        loss = 0

    net_change = gain - loss

    gain_loss_data.append({
        'class': class_name,
        'gain': gain,
        'loss': loss,
        'net_change': net_change
    })

df_gain_loss = pd.DataFrame(gain_loss_data)

# Criar gráfico de ganho/perda
fig = plot_gain_loss_analysis(
    gain_loss_data=df_gain_loss,
    filename="ganho_perda",
    output_dir="outputs",
    title="Análise de Ganho e Perda por Classe",
    figsize=(12, 8),
    scientific_style=True
)

print("✅ Análise de ganho/perda salva em: outputs/ganho_perda.png")
```

### 🎯 5. Matriz de Confusão (para Validação)

**Para avaliar a precisão de classificação:**

```python
from landuse_intensity.matrix_visualization import plot_confusion_matrix

# Criar dados de exemplo para matriz de confusão
# (Em um caso real, isso viria de dados observados vs. previstos)
true_labels = ['Floresta', 'Floresta', 'Agricultura', 'Urbano', 'Floresta']
predicted_labels = ['Floresta', 'Agricultura', 'Agricultura', 'Urbano', 'Floresta']

# Criar DataFrame de confusão
confusion_data = pd.crosstab(
    pd.Series(true_labels, name='Observado'),
    pd.Series(predicted_labels, name='Previsto')
)

# Criar matriz de confusão
fig = plot_confusion_matrix(
    confusion_matrix=confusion_data,
    filename="matriz_confusao",
    output_dir="outputs",
    title="Matriz de Confusão - Validação da Classificação",
    figsize=(8, 6),
    normalize='true',                    # Normalizar por linha (observado)
    scientific_style=True
)

print("✅ Matriz de confusão salva em: outputs/matriz_confusao.png")
```

---

## 🔬 Análise Avançada

### Análise de Intensidade Pontius-Aldwaik

```python
from landuse_intensity import IntensityAnalyzer

# Criar analisador de intensidade
analyzer = lui.IntensityAnalyzer(ct)

# Análise completa
results = analyzer.full_analysis()

print("📊 Análise de Intensidade - Nível de Intervalo:")
print(f"Taxa de mudança anual: {results.interval.annual_change_rate:.2f}%")
print(f"Intensidade de mudança: {results.interval.change_intensity:.2f}")

print("\n📊 Análise de Intensidade - Nível de Categoria:")
for category_result in results.category:
    print(f"{category_result.category_name}:")
    print(f"  Ganho relativo: {category_result.relative_gain:.2f}")
    print(f"  Perda relativa: {category_result.relative_loss:.2f}")
```

### Análise Multi-Temporal

```python
from landuse_intensity import MultiStepAnalyzer

# Análise com múltiplos períodos
rasters = [raster_t1, raster_t2]  # Adicione mais rasters conforme necessário
time_labels = ['2000', '2020']

multi_analyzer = lui.MultiStepAnalyzer(rasters, time_labels)
multi_results = multi_analyzer.analyze_all_steps()

print("📈 Análise Multi-Temporal:")
for step_name, step_result in multi_results.items():
    print(f"{step_name}: {step_result.interval.annual_change_rate:.2f}% mudança anual")
```

### Trabalhando com Arquivos Raster Reais

```python
# Carregar arquivos GeoTIFF
raster_2000, metadata_2000 = lui.read_raster("caminho/para/landuse_2000.tif")
raster_2020, metadata_2020 = lui.read_raster("caminho/para/landuse_2020.tif")

# Verificar se os rasters são compatíveis
print(f"Projeção compatível: {metadata_2000['crs'] == metadata_2020['crs']}")
print(f"Resolução: {metadata_2000['transform'][0]}m x {metadata_2000['transform'][4]}m")

# Criar tabela de contingência
ct_real = lui.ContingencyTable.from_rasters(
    raster_2000, raster_2020,
    labels1=['Floresta', 'Agricultura', 'Urbano', 'Água', 'Pastagem'],
    labels2=['Floresta', 'Agricultura', 'Urbano', 'Água', 'Pastagem']
)

# Análise completa
analyzer_real = lui.IntensityAnalyzer(ct_real)
results_real = analyzer_real.full_analysis()

# Salvar resultados
ct_real.table.to_csv("resultados/contingencia_real.csv")
results_real.to_json("resultados/analise_intensidade.json")
```

---

## 🎨 Galeria de Visualizações

### Tipos de Gráficos Disponíveis

| Tipo | Módulo | Descrição | Melhor Uso |
|------|--------|-----------|------------|
| **Sankey** | `sankey_visualization` | Fluxos interativos entre classes | Mostrar transições detalhadas |
| **Mapa de Calor** | `matrix_visualization` | Intensidade de transições | Comparar magnitudes |
| **Barras** | `bar_chart_visualization` | Comparação de áreas | Análise temporal |
| **Ganho/Perda** | `bar_chart_visualization` | Mudanças positivas/negativas | Identificar tendências |
| **ROC Curve** | `statistical_visualization` | Performance de classificação | Avaliação de modelos |
| **Precisão-Revocação** | `statistical_visualization` | Métricas de classificação | Análise de trade-offs |

### Parâmetros Comuns

Todos os gráficos suportam:

```python
# Parâmetros universais
filename="meu_grafico"        # Nome do arquivo (sem extensão)
output_dir="outputs"          # Pasta de saída
title="Título do Gráfico"     # Título
figsize=(10, 6)              # Tamanho da figura
scientific_style=True        # Estilo científico (fonte serifada, grid)
```

### Exportação Multi-Formato

```python
# Para Sankey (suporta múltiplos formatos)
files = plot_single_step_sankey(
    contingency_data=ct.table,
    export_formats=['html', 'png', 'svg', 'pdf']  # Escolha os formatos
)

# Para outros gráficos (PNG e PDF automático)
plot_transition_matrix_heatmap(
    tabulation_matrix=ct.table,
    filename="matriz"  # Gera .png e .pdf automaticamente
)
```

---

## 📚 Exemplos Práticos Completos

### 🌟 Exemplo 1: Análise Completa de Pequena Área

```python
import landuse_intensity as lui
import pandas as pd
from pathlib import Path

# Criar diretório de saída
output_dir = Path("analise_completa")
output_dir.mkdir(exist_ok=True)

# 1. Carregar dados
raster_t1, raster_t2 = lui.demo_landscape()

# 2. Análise básica
ct = lui.ContingencyTable.from_rasters(raster_t1, raster_t2)
analyzer = lui.IntensityAnalyzer(ct)
results = analyzer.full_analysis()

# 3. Gerar todos os gráficos
from landuse_intensity.sankey_visualization import plot_single_step_sankey
from landuse_intensity.matrix_visualization import plot_transition_matrix_heatmap
from landuse_intensity.bar_chart_visualization import plot_barplot_lulc

# Sankey
plot_single_step_sankey(
    ct.table,
    output_dir=str(output_dir),
    filename="sankey_completo",
    title="Análise Completa de Transições"
)

# Matriz de calor
plot_transition_matrix_heatmap(
    ct.table,
    filename="matriz_completo",
    output_dir=str(output_dir),
    title="Matriz de Transição Completa"
)

# Gráfico de áreas
area_data = []
for class_name in ct.table.index:
    area_data.append({'class': class_name, 'area': ct.table.loc[class_name].sum(), 'period': 'Tempo 1'})
for class_name in ct.table.columns:
    area_data.append({'class': class_name, 'area': ct.table[class_name].sum(), 'period': 'Tempo 2'})

df_areas = pd.DataFrame(area_data)
plot_barplot_lulc(
    df_areas,
    filename="areas_completo",
    output_dir=str(output_dir),
    title="Comparação de Áreas por Período"
)

print(f"✅ Análise completa salva em: {output_dir}")
print(f"📊 {len(list(output_dir.glob('*.png')))} gráficos PNG gerados")
print(f"🌐 {len(list(output_dir.glob('*.html')))} gráficos HTML gerados")
```

### 🌍 Exemplo 2: Estudo de Caso Real - Cerrado

```python
import landuse_intensity as lui
import numpy as np

# Simular dados do Cerrado brasileiro
print("🌍 Análise do Bioma Cerrado")

# Dados simulados (substitua por dados reais)
classes_cerrado = ['Cerrado', 'Cerradão', 'Campo', 'Agricultura', 'Pastagem', 'Silvicultura']

# Criar rasters simulados
np.random.seed(42)
raster_2000 = np.random.choice([0,1,2,3,4,5], size=(500, 500), p=[0.4, 0.2, 0.2, 0.1, 0.05, 0.05])
raster_2020 = np.random.choice([0,1,2,3,4,5], size=(500, 500), p=[0.3, 0.15, 0.15, 0.2, 0.15, 0.05])

# Análise
ct_cerrado = lui.ContingencyTable.from_rasters(
    raster_2000, raster_2020,
    labels1=classes_cerrado,
    labels2=classes_cerrado
)

analyzer_cerrado = lui.IntensityAnalyzer(ct_cerrado)
results_cerrado = analyzer_cerrado.full_analysis()

# Relatório
print("
📊 RELATÓRIO - MUDANÇAS NO CERRADO (2000-2020)"      print("=" * 50)
print(f"Área total analisada: {ct_cerrado.total_area:,} hectares")
print(f"Área que mudou: {ct_cerrado.total_change:,} hectares ({ct_cerrado.total_change/ct_cerrado.total_area*100:.1f}%)")
print(f"Taxa de mudança anual: {results_cerrado.interval.annual_change_rate:.2f}%")

print("
🔄 Principais Transições:"      transitions = ct_cerrado.table.stack()
top_transitions = transitions[transitions > 0].sort_values(ascending=False).head(5)

for (from_class, to_class), area in top_transitions.items():
    if from_class != to_class:
        print(f"  {from_class} → {to_class}: {area:,} hectares")

# Gerar visualizações
from landuse_intensity.sankey_visualization import plot_single_step_sankey

plot_single_step_sankey(
    ct_cerrado.table,
    output_dir="cerrado_results",
    filename="cerrado_transitions",
    title="Transições no Bioma Cerrado (2000-2020)",
    export_formats=['html', 'png', 'pdf']
)

print("
✅ Relatório e visualizações salvos em: cerrado_results/"  print("🌐 Arquivo interativo: cerrado_results/cerrado_transitions.html")
```

---

## 🔧 Solução de Problemas

### Erro: "Módulo não encontrado"

```python
# Verificar instalação
import landuse_intensity as lui
print("Versão:", lui.__version__)

# Se não funcionar, reinstalar
pip uninstall landuse-intensity-analysis
pip install landuse-intensity-analysis
```

### Erro: "Dados inválidos"

```python
# Validar dados antes da análise
from landuse_intensity.utils import validate_raster_data

is_valid, message = validate_raster_data(raster_t1, raster_t2)
if not is_valid:
    print(f"Erro nos dados: {message}")
```

### Performance com Grandes Rasters

```python
# Para rasters muito grandes, processe em blocos
from landuse_intensity.utils import process_raster_in_chunks

results = process_raster_in_chunks(
    raster_t1, raster_t2,
    chunk_size=(1000, 1000),
    overlap=50
)
```

---

## 📚 Referências

### Metodologia

- **Aldwaik, S. Z., & Pontius Jr, R. G. (2012).** Intensity analysis to unify measurements of size and stationarity of land changes by interval, category, and transition. *Landscape and Urban Planning*, 106(1), 103-114.

- **Pontius Jr, R. G., & Millones, M. (2011).** Death to Kappa: birth of quantity disagreement and allocation disagreement for accuracy assessment. *International Journal of Remote Sensing*, 32(15), 4407-4429.

### Implementação

- **Documentação Oficial**: [Read the Docs](https://landuse-intensity-analysis.readthedocs.io/)
- **Repositório GitHub**: [Código Fonte](https://github.com/ils15/LandUse-Intensity-Analysis)
- **Exemplos**: Pasta `examples/` no repositório

---

## 🤝 Contribuição

Contribuições são bem-vindas!

1. Fork o projeto
2. Crie uma branch para sua feature (`git checkout -b feature/nova-feature`)
3. Commit suas mudanças (`git commit -am 'Adiciona nova feature'`)
4. Push para a branch (`git push origin feature/nova-feature`)
5. Abra um Pull Request

---

## 📄 Licença

Este projeto está licenciado sob a Licença MIT - veja o arquivo [LICENSE](LICENSE) para detalhes.

---

## 🆘 Suporte

**Precisa de ajuda?**

1. 📖 **Documentação**: Leia os exemplos na pasta `examples/`
2. 🐛 **Issues**: [GitHub Issues](https://github.com/ils15/LandUse-Intensity-Analysis/issues)
3. 💬 **Discussões**: [GitHub Discussions](https://github.com/ils15/LandUse-Intensity-Analysis/discussions)
4. 📧 **Email**: Para questões específicas

---

> Desenvolvido com ❤️ para a comunidade de ciências ambientais e geotecnologia

**Versão Atual**: 2.0.3 | **Python**: 3.8+ | **Mantenedor**: [ils15](https://github.com/ils15)

## 🌟 What does it do?

Transform your land cover raster data into meaningful insights about environmental change:

1. **Quantify Changes**: Calculate transition matrices and area statistics from multi-temporal raster data
2. **Intensity Analysis**: Apply the proven Pontius-Aldwaik methodology for interval, category, and transition-level analysis
3. **Rich Visualizations**: Create publication-ready Sankey diagrams, heatmaps, spatial maps, and statistical plots
4. **Spatial Analysis**: Process GeoTIFF files with built-in raster handling and spatial change detection

## ✨ Key Features

- 🔬 **Scientific Rigor**: Implements the established Pontius-Aldwaik intensity analysis methodology
- 📊 **Rich Visualizations**: Sankey diagrams, transition matrices, spatial maps, and statistical plots using matplotlib and plotly
- 🗺️ **Spatial Support**: Direct processing of GeoTIFF files and numpy arrays
- 🎯 **Object-Oriented Design**: Clean API with `ContingencyTable`, `IntensityAnalyzer`, and `MultiStepAnalyzer` classes
- 📈 **Multi-temporal Analysis**: Support for analyzing changes across multiple time periods
- 🔧 **Comprehensive Toolkit**: Complete suite of utility functions for data processing and validation

## 🚀 Installation

```bash
pip install landuse-intensity-analysis
```

## 📖 Quick Start

### Basic Analysis Example

```python
import numpy as np
import landuse_intensity as lui

# Step 1: Create contingency table from rasters
# Example with 2 time periods and 3 land use classes
raster_t1 = np.array([[1, 1, 2], [1, 2, 3], [2, 3, 3]])  # Time 1
raster_t2 = np.array([[1, 2, 2], [2, 2, 3], [3, 3, 3]])  # Time 2

# Create contingency table
ct = lui.ContingencyTable.from_rasters(
    raster_t1, raster_t2, 
    labels1=['Forest', 'Agriculture', 'Urban', 'Water'],
    labels2=['Forest', 'Agriculture', 'Urban', 'Water']
)

# Step 2: Run intensity analysis
analyzer = lui.IntensityAnalyzer(ct)
results = analyzer.full_analysis()

# Step 3: Display results
print("Contingency Table:")
print(ct.table)
print(f"\nTotal Change: {ct.total_change} pixels")
print(f"Persistence: {ct.persistence} pixels")

# Step 4: Create visualizations
from landuse_intensity import visualization as viz

# Sankey diagram
viz.plot_single_step_sankey(
    ct.table, 
    title="Land Use Transitions",
    save_path="sankey_diagram.html"
)

# Transition matrix heatmap
viz.plot_transition_matrix_heatmap(
    ct.table,
    title="Land Use Transition Matrix",
    save_path="transition_matrix.png"
)
```

### Working with Real Raster Files

```python
import landuse_intensity as lui

# Load raster data
raster1, metadata1 = lui.read_raster("land_cover_2000.tif")
raster2, metadata2 = lui.read_raster("land_cover_2020.tif")

# Create contingency table
contingency_df = lui.raster_to_contingency_table(
    raster1, raster2,
    class_names=['Forest', 'Agriculture', 'Urban', 'Water']
)

# Initialize analysis
ct = lui.ContingencyTable(contingency_df)
analyzer = lui.IntensityAnalyzer(ct)

# Perform complete analysis
results = analyzer.analyze()
print("Interval Level Analysis:", results['interval'])
print("Category Level Analysis:", results['category'])
```

### Multi-Temporal Analysis

```python
import landuse_intensity as lui

# Load multiple time periods
rasters = [
    lui.read_raster("land_cover_1990.tif")[0],
    lui.read_raster("land_cover_2000.tif")[0], 
    lui.read_raster("land_cover_2010.tif")[0],
    lui.read_raster("land_cover_2020.tif")[0]
]

time_labels = ['1990', '2000', '2010', '2020']

# Multi-step analysis
multi_analyzer = lui.MultiStepAnalyzer(rasters, time_labels)
multi_results = multi_analyzer.analyze_all_steps()

print("Multi-step Analysis Results:")
for step, result in multi_results.items():
    print(f"{step}: {result['interval']['annual_change_rate']:.2f}% annual change")
```

## � Complete API Reference

### Core Classes

#### ContingencyTable

Main class for handling transition matrices:

```python
# Create from rasters
ct = lui.ContingencyTable.from_rasters(raster1, raster2, labels1, labels2)

# Create from existing data  
ct = lui.ContingencyTable(dataframe_or_array)

# Properties
ct.table              # Access transition matrix
ct.total_area        # Total number of pixels/area
ct.persistence       # Unchanged pixels
ct.total_change      # Changed pixels
ct.validate()        # Validate table structure
```

#### IntensityAnalyzer
Implements Pontius-Aldwaik intensity analysis:

```python
analyzer = lui.IntensityAnalyzer(contingency_table)

# Analysis methods
analyzer.analyze_interval_level()    # Overall change intensity
analyzer.analyze_category_level()    # Class-specific gains/losses  
analyzer.analyze_transition_level(from_class, to_class)  # Transition intensity
analyzer.analyze()                   # Complete analysis
analyzer.full_analysis()            # Returns AnalysisResults object
```

#### MultiStepAnalyzer
For multi-temporal analysis:

```python
analyzer = lui.MultiStepAnalyzer(raster_list, time_labels)

analyzer.analyze_all_steps()         # Step-by-step analysis
analyzer.analyze_overall_change()    # Overall change summary
analyzer.compare_step_vs_overall()   # Compare step vs overall rates
```

#### ChangeAnalyzer
For spatial change detection:

```python
change_analyzer = lui.ChangeAnalyzer(raster1, raster2)

change_analyzer.analyze()            # Basic change detection
change_analyzer.detect_hotspots()    # Change hotspot detection
change_analyzer.create_change_map()  # Spatial change mapping
```

### Visualization Functions

#### Graph Visualizations
From `landuse_intensity.graph_visualization`:

```python
from landuse_intensity import graph_visualization as gv

# Sankey diagrams
gv.plot_single_step_sankey(
    contingency_table, 
    title="Land Use Transitions",
    save_path="sankey.html"
)

# Transition matrix heatmaps
gv.plot_transition_matrix_heatmap(
    contingency_table,
    title="Transition Matrix",
    save_path="heatmap.png"
)

# Bar plots for LULC analysis
gv.plot_barplot_lulc(
    lulc_data,
    title="Land Use Areas",
    save_path="barplot.png"
)

# Gain/Loss analysis
gv.plot_gain_loss_analysis(
    contingency_table,
    title="Gain/Loss Analysis"
)

# Accuracy assessment
gv.plot_accuracy_assessment(
    observed, predicted,
    save_path="accuracy.png"
)

# Confusion matrix
gv.plot_confusion_matrix(
    true_labels, predicted_labels
)
```

#### Spatial Visualizations  
From `landuse_intensity.map_visualization`:

```python
from landuse_intensity import map_visualization as mv

# Spatial change maps
mv.plot_spatial_change_map(
    raster_t1, raster_t2,
    title="Land Use Change Map",
    save_path="change_map.png"
)

# Multi-temporal maps
mv.plot_multi_temporal_maps(
    raster_list, time_labels,
    title="Land Use Over Time"
)

# Change detection
mv.plot_change_detection_map(
    raster_t1, raster_t2,
    title="Change Detection"
)

# Interactive maps
mv.plot_interactive_map(
    raster_data, coordinates,
    save_path="interactive_map.html"
)

# Elevation models
mv.plot_elevation_model(
    elevation_raster,
    title="Digital Elevation Model"
)
```

#### Advanced Visualizations
From `landuse_intensity.visualization`:

```python
from landuse_intensity import visualization as viz

# Intensity analysis plots
viz.plot_intensity_analysis(
    intensity_results,
    title="Pontius Intensity Analysis"
)

# Multi-step Sankey
viz.plot_multi_step_sankey(
    transitions_list,
    time_labels=time_labels
)

# Spatial change with persistence
viz.plot_persistence_map(
    raster_t1, raster_t2,
    title="Persistence Analysis"
)

# Temporal land change
viz.plot_temporal_land_change(
    raster_list, time_labels,
    save_path="temporal_change.png"
)

# Change frequency mapping
viz.plot_change_frequency_map(
    raster_list,
    title="Change Frequency Analysis"
)
```

### Utility Functions

#### Data Processing
```python
import landuse_intensity as lui

# Demo data generation
raster_t1, raster_t2 = lui.demo_landscape()

# Data validation
is_valid = lui.validate_data(raster_data)

# Area calculations
area_matrix = lui.calculate_area_matrix(contingency_table, pixel_area=900)

# Change summary
summary = lui.get_change_summary(contingency_table)

# Area formatting
label = lui.format_area_label(1500.5, units="hectares")

# Transition naming
names = lui.create_transition_names(
    from_classes=['Forest', 'Agriculture'], 
    to_classes=['Urban', 'Water']
)
```

#### Image Processing
```python
import landuse_intensity as lui

# Create contingency table from rasters
ct = lui.create_contingency_table(raster1, raster2, labels=['Forest', 'Urban'])

# Calculate change map
change_map = lui.calculate_change_map(raster_t1, raster_t2)

# Apply majority filter  
filtered = lui.apply_majority_filter(raster, window_size=3)

# Calculate patch metrics
metrics = lui.calculate_patch_metrics(raster, class_value=1)

# Resample raster
resampled = lui.resample_raster(raster, target_shape=(100, 100))

# Align rasters
aligned1, aligned2 = lui.align_rasters(raster1, raster2)

# Validate raster
is_valid = lui.validate_raster(raster)

# Mask raster
masked = lui.mask_raster(raster, mask, nodata_value=-9999)
```

#### Raster Handling
```python
import landuse_intensity as lui

# Read raster file
raster_data, metadata = lui.read_raster("landcover.tif")

# Write raster file
lui.write_raster(
    raster_data, "output.tif", 
    metadata=metadata,
    nodata_value=-9999
)

# Convert rasters to contingency table
contingency_df = lui.raster_to_contingency_table(
    raster1, raster2,
    class_names=['Forest', 'Agriculture', 'Urban']
)

# Load demo data
demo_raster1, demo_raster2 = lui.load_demo_data()

# Raster summary statistics
summary = lui.raster_summary(raster)

# Reclassify raster
reclassified = lui.reclassify_raster(
    raster, 
    reclass_dict={1: 10, 2: 20, 3: 30}
)
```

## 📊 Analysis Functions

### Main Analysis Function
```python
# One-step comprehensive analysis
results = lui.analyze_land_use_change(
    raster1=raster_t1,
    raster2=raster_t2, 
    area_calculation=True,
    intensity_analysis=True,
    save_tables=True,
    output_dir="./results/"
)
```

## 🎯 Complete Example: Real Dataset Analysis

```python
import landuse_intensity as lui
import numpy as np

# 1. Load real raster data
raster_2000, meta_2000 = lui.read_raster("cerrado_2000.tif")
raster_2010, meta_2010 = lui.read_raster("cerrado_2010.tif") 
raster_2020, meta_2020 = lui.read_raster("cerrado_2020.tif")

# 2. Create contingency tables
ct_2000_2010 = lui.ContingencyTable.from_rasters(
    raster_2000, raster_2010,
    labels1=['Forest', 'Savanna', 'Agriculture', 'Pasture', 'Urban'],
    labels2=['Forest', 'Savanna', 'Agriculture', 'Pasture', 'Urban']
)

ct_2010_2020 = lui.ContingencyTable.from_rasters(
    raster_2010, raster_2020,
    labels1=['Forest', 'Savanna', 'Agriculture', 'Pasture', 'Urban'],
    labels2=['Forest', 'Savanna', 'Agriculture', 'Pasture', 'Urban']
)

# 3. Intensity analysis
analyzer_2000_2010 = lui.IntensityAnalyzer(ct_2000_2010)
analyzer_2010_2020 = lui.IntensityAnalyzer(ct_2010_2020)

results_2000_2010 = analyzer_2000_2010.analyze()
results_2010_2020 = analyzer_2010_2020.analyze()

# 4. Multi-temporal analysis
multi_analyzer = lui.MultiStepAnalyzer(
    [raster_2000, raster_2010, raster_2020],
    ['2000', '2010', '2020']
)
multi_results = multi_analyzer.analyze_all_steps()

# 5. Create visualizations
from landuse_intensity import graph_visualization as gv
from landuse_intensity import map_visualization as mv

# Sankey diagrams for each period
gv.plot_single_step_sankey(
    ct_2000_2010.table,
    title="Cerrado Land Use Transitions 2000-2010",
    save_path="sankey_2000_2010.html"
)

gv.plot_single_step_sankey(
    ct_2010_2020.table, 
    title="Cerrado Land Use Transitions 2010-2020",
    save_path="sankey_2010_2020.html"
)

# Spatial change maps
mv.plot_spatial_change_map(
    raster_2000, raster_2020,
    title="Cerrado Land Use Change 2000-2020",
    save_path="cerrado_change_map.png"
)

# Multi-temporal maps
mv.plot_multi_temporal_maps(
    [raster_2000, raster_2010, raster_2020],
    ['2000', '2010', '2020'],
    title="Cerrado Land Use Evolution"
)

# 6. Export results
print("=== ANALYSIS RESULTS ===")
print(f"Period 2000-2010:")
print(f"  Annual change rate: {results_2000_2010['interval']['annual_change_rate']:.2f}%")
print(f"  Total change: {ct_2000_2010.total_change} pixels")

print(f"Period 2010-2020:")  
print(f"  Annual change rate: {results_2010_2020['interval']['annual_change_rate']:.2f}%")
print(f"  Total change: {ct_2010_2020.total_change} pixels")

# Export contingency tables
ct_2000_2010.table.to_csv("contingency_2000_2010.csv")
ct_2010_2020.table.to_csv("contingency_2010_2020.csv")
```

## 📚 References

This library implements the Pontius-Aldwaik intensity analysis methodology:

- Aldwaik, S. Z., & Pontius Jr, R. G. (2012). Intensity analysis to unify measurements of size and stationarity of land changes by interval, category, and transition. *Landscape and Urban Planning*, 106(1), 103-114.

- Pontius Jr, R. G., & Millones, M. (2011). Death to Kappa: birth of quantity disagreement and allocation disagreement for accuracy assessment. *International Journal of Remote Sensing*, 32(15), 4407-4429.

## 📄 License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## 🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

## 📮 Support

If you encounter any issues or have questions:

1. Check the examples in the `examples/` directory
2. Read the documentation
3. Open an issue on GitHub

## 🎯 Version Information

- **Current Version**: 2.0.3
- **Python Requirements**: Python 3.8+
- **Key Dependencies**: numpy, pandas, matplotlib, plotly, rasterio

---

> Made with ❤️ for the geospatial and environmental science community

- **Smart Detection**: No need to manually specify analysis type
- **Methodology Compatible**: Follows established methodology
- **Flexible**: Override auto-detection when needed
- **Unified Interface**: Single function for all analysis types

### Raster Stacking and Year Detection

#### Raster Stacking Options

**1. Automatic Directory Loading:**

```python
from landuse_intensity.raster import load_rasters

# Load all .tif files from directory
rasters = load_rasters("data/landuse/")
# Automatically finds and stacks: landuse_1990.tif, landuse_2000.tif, landuse_2010.tif
```

**2. Manual File Selection:**

```python
# Load specific files in custom order
files = ["landuse_1990.tif", "landuse_2005.tif", "landuse_2010.tif"]
rasters = load_rasters(files)
```

## Scientific Background

This library implements the Pontius-Aldwaik intensity analysis methodology, which provides a comprehensive framework for understanding land use change patterns. The methodology distinguishes between:

- **Quantity of change**: How much land changed category
- **Exchange**: Land that would have changed even if proportions remained constant
- **Shift**: Land that changed due to systematic transitions

## API Reference

### Main Classes

#### `ContingencyTable`

Main class for creating and managing transition matrices.

**Methods:**

- `from_rasters()`: Create contingency table from raster data
- `validate()`: Validate table data integrity
- `get_summary_stats()`: Get statistical summary
- `get_transition_matrix()`: Get transition matrix representation

#### `IntensityAnalyzer`

Class for performing Pontius-Aldwaik intensity analysis.

**Methods:**

- `analyze()`: Perform intensity analysis on contingency table
- `full_analysis()`: Complete analysis with all metrics
- `get_category_analysis()`: Category-level intensity analysis
- `get_transition_analysis()`: Transition-level intensity analysis

### Data Format

The library expects land use data in numpy arrays or pandas DataFrames:

```python
# Raster data (numpy arrays)
raster_1990 = np.array([[1, 1, 2], [1, 2, 3], [2, 3, 3]])
raster_2000 = np.array([[1, 2, 2], [2, 2, 3], [3, 3, 3]])

# Or pandas DataFrame
contingency_df = pd.DataFrame({
    'Forest->Forest': [100, 0, 0],
    'Forest->Agriculture': [20, 0, 0],
    'Agriculture->Agriculture': [0, 80, 0]
})
```

## Visualization Gallery

The library provides several types of visualizations:

- **Intensity Maps**: Spatial distribution of land use intensity
- **Transition Matrices**: Category transition probabilities
- **Time Series Plots**: Temporal evolution of land use patterns
- **Chord Diagrams**: Flow visualization between categories
- **Sankey Diagrams**: Flow-based transition visualization

## Advanced Usage

### Working with Large Datasets

```python
# For large raster datasets, consider memory usage
import numpy as np
from landuse_intensity import ContingencyTable

# Process in chunks for very large rasters
def process_large_raster(raster1, raster2, chunk_size=1000):
    height, width = raster1.shape
    results = []
    
    for i in range(0, height, chunk_size):
        for j in range(0, width, chunk_size):
            chunk1 = raster1[i:i+chunk_size, j:j+chunk_size]
            chunk2 = raster2[i:i+chunk_size, j:j+chunk_size]
            
            ct = ContingencyTable.from_rasters(chunk1, chunk2)
            results.append(ct)
    
    return results
```

### Custom Analysis Parameters

```python
# Customize analysis with specific parameters
from landuse_intensity import IntensityAnalyzer

# Create analyzer with custom settings
analyzer = IntensityAnalyzer()

# Perform analysis with specific options
results = analyzer.analyze(
    contingency_table=ct,
    include_interval=True,
    include_category=True,
    include_transition=True
)
```

### Spatial Analysis

```python
# Load geospatial data
import rasterio
import xarray as xr

with rasterio.open('land_use_1990.tif') as src:
    data_1990 = src.read(1)

with rasterio.open('land_use_2000.tif') as src:
    data_2000 = src.read(1)

# Perform spatial intensity analysis
spatial_results = analyzer.spatial_intensity_analysis(
    data_1990, data_2000,
    transform=src.transform
)
```

## 📚 Complete Documentation

## Usage

### 🔧 Key Features

- **Raster Loading**: Multiple methods (automatic, manual, dataset)
- **Year Detection**: Automatic year extraction from filenames
- **Contingency Tables**: Transition matrix generation
- **Intensity Analysis**: Pontius-Aldwaik methodology
- **Visualizations**: Modern interactive plots
- **Change Maps**: Spatial analysis and mapping
- **Export Options**: CSV, JSON, HTML formats

### 📋 Complete Analysis Workflow

```python
# 1. Load raster data
from landuse_intensity import read_raster
raster1, meta1 = read_raster("landuse_1990.tif")
raster2, meta2 = read_raster("landuse_2000.tif")

# 2. Generate contingency table
from landuse_intensity import ContingencyTable
ct = ContingencyTable.from_rasters(raster1, raster2)

# 3. Perform intensity analysis
from landuse_intensity import IntensityAnalyzer
analyzer = IntensityAnalyzer(ct)
results = analyzer.full_analysis()

# 4. Create visualizations
from landuse_intensity import visualization as viz
viz.plot_single_step_sankey(ct.table, title="Land Use Transitions")
viz.plot_transition_matrix_heatmap(ct.table, title="Transition Matrix")

# 5. Generate change maps
from landuse_intensity import image_processing
change_map = image_processing.calculate_change_map(raster1, raster2)

# 6. Export results
ct.table.to_csv("contingency_table.csv")
```

## Examples

The library includes comprehensive examples demonstrating various land use analysis capabilities:

```python
# Basic intensity analysis example
import numpy as np
import landuse_intensity as lui

# Generate demo data
raster_t1, raster_t2 = lui.demo_landscape()

# Create contingency table
ct = lui.ContingencyTable.from_rasters(raster_t1, raster_t2)

# Perform intensity analysis
analyzer = lui.IntensityAnalyzer(ct)
results = analyzer.full_analysis()

# Create visualizations
import landuse_intensity.visualization as viz
viz.plot_single_step_sankey(ct.table, title="Land Use Transitions")
viz.plot_transition_matrix_heatmap(ct.table, title="Transition Matrix")

print(f"Analysis completed! Total change: {ct.total_change} pixels")
```

## Contributing

We welcome contributions! Please see our GitHub repository for details on contributing to the project.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Citation

If you use this library in your research, please cite:

```bibtex
@software{landuse_intensity_analysis,
  title = {Land Use Intensity Analysis},
  author = {LandUse Intensity Analysis Contributors},
  url = {https://github.com/your-repo/landuse-intensity-analysis},
  version = {1.0.3a1},
  date = {2024}
}
```

## Support

- **Documentation**: [Read the Docs](https://landuse-intensity-analysis.readthedocs.io/)
- **Issues**: [GitHub Issues](https://github.com/your-repo/landuse-intensity-analysis/issues)
- **Discussions**: [GitHub Discussions](https://github.com/your-repo/landuse-intensity-analysis/discussions)

## Related Projects

- [Pontius Research Group](https://www.clarku.edu/departments/geography/pontius/): Original methodology developers
- [GDAL](https://gdal.org/): Geospatial data processing
- [Rasterio](https://rasterio.readthedocs.io/): Python geospatial raster processing
- [Xarray](https://xarray.pydata.org/): N-dimensional arrays for Python

<!-- Test commit for workflow validation -->

            

Raw data

            {
    "_id": null,
    "home_page": null,
    "name": "landuse-intensity-analysis",
    "maintainer": null,
    "docs_url": null,
    "requires_python": ">=3.8",
    "maintainer_email": "LandUse Intensity Analysis Contributors <contact@landuse-intensity.org>",
    "keywords": "land-use, intensity-analysis, pontius, aldwaik, remote-sensing, gis, land-change, spatial-analysis, environmental-science",
    "author": null,
    "author_email": "LandUse Intensity Analysis Contributors <contact@landuse-intensity.org>",
    "download_url": null,
    "platform": null,
    "description": "# \ud83c\udf0d Land Use Intensity Analysis\r\n\r\n[![PyPI version](https://badge.fury.io/py/landuse-intensity-analysis.svg)](https://pypi.org/project/landuse-intensity-analysis/)\r\n[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)\r\n[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)\r\n\r\n> **Biblioteca Python completa para an\u00e1lise cient\u00edfica de mudan\u00e7as no uso da terra usando a metodologia de an\u00e1lise de intensidade Pontius-Aldwaik**\r\n\r\n---\r\n\r\n## \ud83d\udccb Sum\u00e1rio\r\n\r\n- [\ud83d\ude80 Instala\u00e7\u00e3o R\u00e1pida](#-instala\u00e7\u00e3o-r\u00e1pida)\r\n- [\ud83c\udfaf Guia para Iniciantes](#-guia-para-iniciantes)\r\n- [\ud83d\udcca Como Gerar Gr\u00e1ficos](#-como-gerar-gr\u00e1ficos)\r\n- [\ud83d\udd2c An\u00e1lise Avan\u00e7ada](#-an\u00e1lise-avan\u00e7ada)\r\n- [\ud83d\udcda Refer\u00eancias](#-refer\u00eancias)\r\n\r\n---\r\n\r\n## \ud83d\ude80 Instala\u00e7\u00e3o R\u00e1pida\r\n\r\n```bash\r\npip install landuse-intensity-analysis\r\n```\r\n\r\n**Verificar instala\u00e7\u00e3o:**\r\n\r\n```python\r\nimport landuse_intensity as lui\r\nprint(\"\u2705 Instala\u00e7\u00e3o bem-sucedida!\")\r\n```\r\n\r\n---\r\n\r\n## \ud83c\udfaf Guia para Iniciantes\r\n\r\n### Primeiro Passo: Analisar Mudan\u00e7as no Uso da Terra\r\n\r\nVamos come\u00e7ar com um exemplo simples usando dados de demonstra\u00e7\u00e3o:\r\n\r\n```python\r\nimport landuse_intensity as lui\r\nimport numpy as np\r\n\r\n# 1. Carregar dados de exemplo\r\nprint(\"\ud83d\udcca Carregando dados de exemplo...\")\r\nraster_t1, raster_t2 = lui.demo_landscape()\r\n\r\nprint(f\"Raster 1 (Tempo 1): {raster_t1.shape}\")\r\nprint(f\"Raster 2 (Tempo 2): {raster_t2.shape}\")\r\n\r\n# 2. Criar tabela de conting\u00eancia\r\nprint(\"\\n\ud83d\udd04 Criando tabela de conting\u00eancia...\")\r\nct = lui.ContingencyTable.from_rasters(\r\n    raster_t1, raster_t2,\r\n    labels1=['Floresta', 'Agricultura', 'Urbano', '\u00c1gua'],\r\n    labels2=['Floresta', 'Agricultura', 'Urbano', '\u00c1gua']\r\n)\r\n\r\nprint(\"Tabela de conting\u00eancia criada:\")\r\nprint(ct.table)\r\n\r\n# 3. An\u00e1lise b\u00e1sica\r\nprint(f\"\\n\ud83d\udcc8 Estat\u00edsticas b\u00e1sicas:\")\r\nprint(f\"\u00c1rea total: {ct.total_area} pixels\")\r\nprint(f\"\u00c1rea que mudou: {ct.total_change} pixels ({ct.total_change/ct.total_area*100:.1f}%)\")\r\nprint(f\"\u00c1rea que permaneceu igual: {ct.persistence} pixels ({ct.persistence/ct.total_area*100:.1f}%)\")\r\n```\r\n\r\n**Sa\u00edda esperada:**\r\n\r\n```text\r\n\ud83d\udcca Carregando dados de exemplo...\r\nRaster 1 (Tempo 1): (100, 100)\r\nRaster 2 (Tempo 2): (100, 100)\r\n\r\n\ud83d\udd04 Criando tabela de conting\u00eancia...\r\nTabela de conting\u00eancia criada:\r\n            Floresta  Agricultura  Urbano  \u00c1gua\r\nFloresta          450           30      10     5\r\nAgricultura        25          380      15     0\r\nUrbano              5           20     360     0\r\n\u00c1gua                0            0       0   100\r\n\r\n\ud83d\udcc8 Estat\u00edsticas b\u00e1sicas:\r\n\u00c1rea total: 10000 pixels\r\n\u00c1rea que mudou: 110 pixels (1.1%)\r\n\u00c1rea que permaneceu igual: 9890 pixels (98.9%)\r\n```\r\n\r\n---\r\n\r\n## \ud83d\udcca Como Gerar Gr\u00e1ficos\r\n\r\n### \ud83c\udfa8 M\u00f3dulos de Visualiza\u00e7\u00e3o Dispon\u00edveis\r\n\r\nA biblioteca possui **5 m\u00f3dulos especializados** para diferentes tipos de gr\u00e1ficos:\r\n\r\n| M\u00f3dulo | Tipo de Gr\u00e1fico | Uso Principal |\r\n|--------|----------------|---------------|\r\n| `sankey_visualization` | Diagramas Sankey | Transi\u00e7\u00f5es entre classes |\r\n| `matrix_visualization` | Matrizes e mapas de calor | Matrizes de transi\u00e7\u00e3o |\r\n| `bar_chart_visualization` | Gr\u00e1ficos de barras | An\u00e1lise de \u00e1reas e mudan\u00e7as |\r\n| `statistical_visualization` | Gr\u00e1ficos estat\u00edsticos | An\u00e1lise de desempenho |\r\n| `visualization_utils` | Utilit\u00e1rios | Fun\u00e7\u00f5es auxiliares |\r\n\r\n### \ud83d\udcc8 1. Diagrama Sankey (Transi\u00e7\u00f5es)\r\n\r\n**Para visualizar como as classes de uso da terra se transformam:**\r\n\r\n```python\r\nfrom landuse_intensity.sankey_visualization import plot_single_step_sankey\r\n\r\n# Criar diagrama Sankey interativo\r\nfiles = plot_single_step_sankey(\r\n    contingency_data=ct.table,           # Dados da tabela de conting\u00eancia\r\n    output_dir=\"outputs\",                # Pasta para salvar\r\n    filename=\"transicoes_sankey\",        # Nome do arquivo\r\n    title=\"Transi\u00e7\u00f5es no Uso da Terra\",  # T\u00edtulo do gr\u00e1fico\r\n    width=1000,                          # Largura em pixels\r\n    height=600,                          # Altura em pixels\r\n    min_flow=5,                          # Fluxo m\u00ednimo para mostrar\r\n    export_formats=['html', 'png']       # Formatos de exporta\u00e7\u00e3o\r\n)\r\n\r\nprint(\"\u2705 Arquivos gerados:\")\r\nfor fmt, path in files.items():\r\n    print(f\"  {fmt.upper()}: {path}\")\r\n```\r\n\r\n**Resultado:** Arquivo `outputs/transicoes_sankey.html` com diagrama interativo\r\n\r\n### \ud83d\udd25 2. Mapa de Calor da Matriz de Transi\u00e7\u00e3o\r\n\r\n**Para visualizar a intensidade das transi\u00e7\u00f5es:**\r\n\r\n```python\r\nfrom landuse_intensity.matrix_visualization import plot_transition_matrix_heatmap\r\n\r\n# Criar mapa de calor\r\nfig = plot_transition_matrix_heatmap(\r\n    tabulation_matrix=ct.table,          # Matriz de transi\u00e7\u00e3o\r\n    filename=\"matriz_transicao\",         # Nome do arquivo\r\n    output_dir=\"outputs\",                # Pasta de sa\u00edda\r\n    title=\"Matriz de Transi\u00e7\u00e3o de Uso da Terra\",\r\n    figsize=(10, 8),                     # Tamanho da figura\r\n    cmap=\"YlOrRd\",                       # Paleta de cores\r\n    annot=True,                          # Mostrar valores\r\n    fmt=\".1f\",                           # Formato dos n\u00fameros\r\n    show_percentages=False               # Mostrar em unidades absolutas\r\n)\r\n\r\nprint(\"\u2705 Mapa de calor salvo em: outputs/matriz_transicao.png\")\r\n```\r\n\r\n### \ud83d\udcca 3. Gr\u00e1fico de Barras (\u00c1reas por Classe)\r\n\r\n**Para comparar \u00e1reas de cada classe de uso da terra:**\r\n\r\n```python\r\nimport pandas as pd\r\nfrom landuse_intensity.bar_chart_visualization import plot_barplot_lulc\r\n\r\n# Preparar dados para o gr\u00e1fico\r\narea_data = []\r\nfor class_name in ct.table.index:\r\n    area = ct.table.loc[class_name].sum()\r\n    area_data.append({\r\n        'class': class_name,\r\n        'area': area,\r\n        'time_period': 'Tempo 1'\r\n    })\r\n\r\nfor class_name in ct.table.columns:\r\n    area = ct.table[class_name].sum()\r\n    area_data.append({\r\n        'class': class_name,\r\n        'area': area,\r\n        'time_period': 'Tempo 2'\r\n    })\r\n\r\ndf_areas = pd.DataFrame(area_data)\r\n\r\n# Criar gr\u00e1fico de barras\r\nfig = plot_barplot_lulc(\r\n    data=df_areas,\r\n    filename=\"areas_classes\",\r\n    output_dir=\"outputs\",\r\n    title=\"\u00c1reas por Classe de Uso da Terra\",\r\n    x_col=\"class\",\r\n    y_col=\"area\",\r\n    time_col=\"time_period\",              # Para comparar per\u00edodos\r\n    figsize=(12, 6),\r\n    color_palette=\"Set2\",\r\n    scientific_style=True,\r\n    show_values=True\r\n)\r\n\r\nprint(\"\u2705 Gr\u00e1fico de barras salvo em: outputs/areas_classes.png\")\r\n```\r\n\r\n### \ud83d\udcc8 4. An\u00e1lise de Ganhos e Perdas\r\n\r\n**Para visualizar quais classes ganharam ou perderam \u00e1rea:**\r\n\r\n```python\r\nfrom landuse_intensity.bar_chart_visualization import plot_gain_loss_analysis\r\n\r\n# Preparar dados de ganho/perda\r\ngain_loss_data = []\r\nclasses = list(set(ct.table.index) | set(ct.table.columns))\r\n\r\nfor class_name in classes:\r\n    # Calcular ganhos (entradas)\r\n    if class_name in ct.table.columns:\r\n        gain = ct.table[class_name].sum() - ct.table.loc[class_name, class_name] if class_name in ct.table.index else ct.table[class_name].sum()\r\n    else:\r\n        gain = 0\r\n\r\n    # Calcular perdas (sa\u00eddas)\r\n    if class_name in ct.table.index:\r\n        loss = ct.table.loc[class_name].sum() - ct.table.loc[class_name, class_name] if class_name in ct.table.columns else ct.table.loc[class_name].sum()\r\n    else:\r\n        loss = 0\r\n\r\n    net_change = gain - loss\r\n\r\n    gain_loss_data.append({\r\n        'class': class_name,\r\n        'gain': gain,\r\n        'loss': loss,\r\n        'net_change': net_change\r\n    })\r\n\r\ndf_gain_loss = pd.DataFrame(gain_loss_data)\r\n\r\n# Criar gr\u00e1fico de ganho/perda\r\nfig = plot_gain_loss_analysis(\r\n    gain_loss_data=df_gain_loss,\r\n    filename=\"ganho_perda\",\r\n    output_dir=\"outputs\",\r\n    title=\"An\u00e1lise de Ganho e Perda por Classe\",\r\n    figsize=(12, 8),\r\n    scientific_style=True\r\n)\r\n\r\nprint(\"\u2705 An\u00e1lise de ganho/perda salva em: outputs/ganho_perda.png\")\r\n```\r\n\r\n### \ud83c\udfaf 5. Matriz de Confus\u00e3o (para Valida\u00e7\u00e3o)\r\n\r\n**Para avaliar a precis\u00e3o de classifica\u00e7\u00e3o:**\r\n\r\n```python\r\nfrom landuse_intensity.matrix_visualization import plot_confusion_matrix\r\n\r\n# Criar dados de exemplo para matriz de confus\u00e3o\r\n# (Em um caso real, isso viria de dados observados vs. previstos)\r\ntrue_labels = ['Floresta', 'Floresta', 'Agricultura', 'Urbano', 'Floresta']\r\npredicted_labels = ['Floresta', 'Agricultura', 'Agricultura', 'Urbano', 'Floresta']\r\n\r\n# Criar DataFrame de confus\u00e3o\r\nconfusion_data = pd.crosstab(\r\n    pd.Series(true_labels, name='Observado'),\r\n    pd.Series(predicted_labels, name='Previsto')\r\n)\r\n\r\n# Criar matriz de confus\u00e3o\r\nfig = plot_confusion_matrix(\r\n    confusion_matrix=confusion_data,\r\n    filename=\"matriz_confusao\",\r\n    output_dir=\"outputs\",\r\n    title=\"Matriz de Confus\u00e3o - Valida\u00e7\u00e3o da Classifica\u00e7\u00e3o\",\r\n    figsize=(8, 6),\r\n    normalize='true',                    # Normalizar por linha (observado)\r\n    scientific_style=True\r\n)\r\n\r\nprint(\"\u2705 Matriz de confus\u00e3o salva em: outputs/matriz_confusao.png\")\r\n```\r\n\r\n---\r\n\r\n## \ud83d\udd2c An\u00e1lise Avan\u00e7ada\r\n\r\n### An\u00e1lise de Intensidade Pontius-Aldwaik\r\n\r\n```python\r\nfrom landuse_intensity import IntensityAnalyzer\r\n\r\n# Criar analisador de intensidade\r\nanalyzer = lui.IntensityAnalyzer(ct)\r\n\r\n# An\u00e1lise completa\r\nresults = analyzer.full_analysis()\r\n\r\nprint(\"\ud83d\udcca An\u00e1lise de Intensidade - N\u00edvel de Intervalo:\")\r\nprint(f\"Taxa de mudan\u00e7a anual: {results.interval.annual_change_rate:.2f}%\")\r\nprint(f\"Intensidade de mudan\u00e7a: {results.interval.change_intensity:.2f}\")\r\n\r\nprint(\"\\n\ud83d\udcca An\u00e1lise de Intensidade - N\u00edvel de Categoria:\")\r\nfor category_result in results.category:\r\n    print(f\"{category_result.category_name}:\")\r\n    print(f\"  Ganho relativo: {category_result.relative_gain:.2f}\")\r\n    print(f\"  Perda relativa: {category_result.relative_loss:.2f}\")\r\n```\r\n\r\n### An\u00e1lise Multi-Temporal\r\n\r\n```python\r\nfrom landuse_intensity import MultiStepAnalyzer\r\n\r\n# An\u00e1lise com m\u00faltiplos per\u00edodos\r\nrasters = [raster_t1, raster_t2]  # Adicione mais rasters conforme necess\u00e1rio\r\ntime_labels = ['2000', '2020']\r\n\r\nmulti_analyzer = lui.MultiStepAnalyzer(rasters, time_labels)\r\nmulti_results = multi_analyzer.analyze_all_steps()\r\n\r\nprint(\"\ud83d\udcc8 An\u00e1lise Multi-Temporal:\")\r\nfor step_name, step_result in multi_results.items():\r\n    print(f\"{step_name}: {step_result.interval.annual_change_rate:.2f}% mudan\u00e7a anual\")\r\n```\r\n\r\n### Trabalhando com Arquivos Raster Reais\r\n\r\n```python\r\n# Carregar arquivos GeoTIFF\r\nraster_2000, metadata_2000 = lui.read_raster(\"caminho/para/landuse_2000.tif\")\r\nraster_2020, metadata_2020 = lui.read_raster(\"caminho/para/landuse_2020.tif\")\r\n\r\n# Verificar se os rasters s\u00e3o compat\u00edveis\r\nprint(f\"Proje\u00e7\u00e3o compat\u00edvel: {metadata_2000['crs'] == metadata_2020['crs']}\")\r\nprint(f\"Resolu\u00e7\u00e3o: {metadata_2000['transform'][0]}m x {metadata_2000['transform'][4]}m\")\r\n\r\n# Criar tabela de conting\u00eancia\r\nct_real = lui.ContingencyTable.from_rasters(\r\n    raster_2000, raster_2020,\r\n    labels1=['Floresta', 'Agricultura', 'Urbano', '\u00c1gua', 'Pastagem'],\r\n    labels2=['Floresta', 'Agricultura', 'Urbano', '\u00c1gua', 'Pastagem']\r\n)\r\n\r\n# An\u00e1lise completa\r\nanalyzer_real = lui.IntensityAnalyzer(ct_real)\r\nresults_real = analyzer_real.full_analysis()\r\n\r\n# Salvar resultados\r\nct_real.table.to_csv(\"resultados/contingencia_real.csv\")\r\nresults_real.to_json(\"resultados/analise_intensidade.json\")\r\n```\r\n\r\n---\r\n\r\n## \ud83c\udfa8 Galeria de Visualiza\u00e7\u00f5es\r\n\r\n### Tipos de Gr\u00e1ficos Dispon\u00edveis\r\n\r\n| Tipo | M\u00f3dulo | Descri\u00e7\u00e3o | Melhor Uso |\r\n|------|--------|-----------|------------|\r\n| **Sankey** | `sankey_visualization` | Fluxos interativos entre classes | Mostrar transi\u00e7\u00f5es detalhadas |\r\n| **Mapa de Calor** | `matrix_visualization` | Intensidade de transi\u00e7\u00f5es | Comparar magnitudes |\r\n| **Barras** | `bar_chart_visualization` | Compara\u00e7\u00e3o de \u00e1reas | An\u00e1lise temporal |\r\n| **Ganho/Perda** | `bar_chart_visualization` | Mudan\u00e7as positivas/negativas | Identificar tend\u00eancias |\r\n| **ROC Curve** | `statistical_visualization` | Performance de classifica\u00e7\u00e3o | Avalia\u00e7\u00e3o de modelos |\r\n| **Precis\u00e3o-Revoca\u00e7\u00e3o** | `statistical_visualization` | M\u00e9tricas de classifica\u00e7\u00e3o | An\u00e1lise de trade-offs |\r\n\r\n### Par\u00e2metros Comuns\r\n\r\nTodos os gr\u00e1ficos suportam:\r\n\r\n```python\r\n# Par\u00e2metros universais\r\nfilename=\"meu_grafico\"        # Nome do arquivo (sem extens\u00e3o)\r\noutput_dir=\"outputs\"          # Pasta de sa\u00edda\r\ntitle=\"T\u00edtulo do Gr\u00e1fico\"     # T\u00edtulo\r\nfigsize=(10, 6)              # Tamanho da figura\r\nscientific_style=True        # Estilo cient\u00edfico (fonte serifada, grid)\r\n```\r\n\r\n### Exporta\u00e7\u00e3o Multi-Formato\r\n\r\n```python\r\n# Para Sankey (suporta m\u00faltiplos formatos)\r\nfiles = plot_single_step_sankey(\r\n    contingency_data=ct.table,\r\n    export_formats=['html', 'png', 'svg', 'pdf']  # Escolha os formatos\r\n)\r\n\r\n# Para outros gr\u00e1ficos (PNG e PDF autom\u00e1tico)\r\nplot_transition_matrix_heatmap(\r\n    tabulation_matrix=ct.table,\r\n    filename=\"matriz\"  # Gera .png e .pdf automaticamente\r\n)\r\n```\r\n\r\n---\r\n\r\n## \ud83d\udcda Exemplos Pr\u00e1ticos Completos\r\n\r\n### \ud83c\udf1f Exemplo 1: An\u00e1lise Completa de Pequena \u00c1rea\r\n\r\n```python\r\nimport landuse_intensity as lui\r\nimport pandas as pd\r\nfrom pathlib import Path\r\n\r\n# Criar diret\u00f3rio de sa\u00edda\r\noutput_dir = Path(\"analise_completa\")\r\noutput_dir.mkdir(exist_ok=True)\r\n\r\n# 1. Carregar dados\r\nraster_t1, raster_t2 = lui.demo_landscape()\r\n\r\n# 2. An\u00e1lise b\u00e1sica\r\nct = lui.ContingencyTable.from_rasters(raster_t1, raster_t2)\r\nanalyzer = lui.IntensityAnalyzer(ct)\r\nresults = analyzer.full_analysis()\r\n\r\n# 3. Gerar todos os gr\u00e1ficos\r\nfrom landuse_intensity.sankey_visualization import plot_single_step_sankey\r\nfrom landuse_intensity.matrix_visualization import plot_transition_matrix_heatmap\r\nfrom landuse_intensity.bar_chart_visualization import plot_barplot_lulc\r\n\r\n# Sankey\r\nplot_single_step_sankey(\r\n    ct.table,\r\n    output_dir=str(output_dir),\r\n    filename=\"sankey_completo\",\r\n    title=\"An\u00e1lise Completa de Transi\u00e7\u00f5es\"\r\n)\r\n\r\n# Matriz de calor\r\nplot_transition_matrix_heatmap(\r\n    ct.table,\r\n    filename=\"matriz_completo\",\r\n    output_dir=str(output_dir),\r\n    title=\"Matriz de Transi\u00e7\u00e3o Completa\"\r\n)\r\n\r\n# Gr\u00e1fico de \u00e1reas\r\narea_data = []\r\nfor class_name in ct.table.index:\r\n    area_data.append({'class': class_name, 'area': ct.table.loc[class_name].sum(), 'period': 'Tempo 1'})\r\nfor class_name in ct.table.columns:\r\n    area_data.append({'class': class_name, 'area': ct.table[class_name].sum(), 'period': 'Tempo 2'})\r\n\r\ndf_areas = pd.DataFrame(area_data)\r\nplot_barplot_lulc(\r\n    df_areas,\r\n    filename=\"areas_completo\",\r\n    output_dir=str(output_dir),\r\n    title=\"Compara\u00e7\u00e3o de \u00c1reas por Per\u00edodo\"\r\n)\r\n\r\nprint(f\"\u2705 An\u00e1lise completa salva em: {output_dir}\")\r\nprint(f\"\ud83d\udcca {len(list(output_dir.glob('*.png')))} gr\u00e1ficos PNG gerados\")\r\nprint(f\"\ud83c\udf10 {len(list(output_dir.glob('*.html')))} gr\u00e1ficos HTML gerados\")\r\n```\r\n\r\n### \ud83c\udf0d Exemplo 2: Estudo de Caso Real - Cerrado\r\n\r\n```python\r\nimport landuse_intensity as lui\r\nimport numpy as np\r\n\r\n# Simular dados do Cerrado brasileiro\r\nprint(\"\ud83c\udf0d An\u00e1lise do Bioma Cerrado\")\r\n\r\n# Dados simulados (substitua por dados reais)\r\nclasses_cerrado = ['Cerrado', 'Cerrad\u00e3o', 'Campo', 'Agricultura', 'Pastagem', 'Silvicultura']\r\n\r\n# Criar rasters simulados\r\nnp.random.seed(42)\r\nraster_2000 = np.random.choice([0,1,2,3,4,5], size=(500, 500), p=[0.4, 0.2, 0.2, 0.1, 0.05, 0.05])\r\nraster_2020 = np.random.choice([0,1,2,3,4,5], size=(500, 500), p=[0.3, 0.15, 0.15, 0.2, 0.15, 0.05])\r\n\r\n# An\u00e1lise\r\nct_cerrado = lui.ContingencyTable.from_rasters(\r\n    raster_2000, raster_2020,\r\n    labels1=classes_cerrado,\r\n    labels2=classes_cerrado\r\n)\r\n\r\nanalyzer_cerrado = lui.IntensityAnalyzer(ct_cerrado)\r\nresults_cerrado = analyzer_cerrado.full_analysis()\r\n\r\n# Relat\u00f3rio\r\nprint(\"\r\n\ud83d\udcca RELAT\u00d3RIO - MUDAN\u00c7AS NO CERRADO (2000-2020)\"      print(\"=\" * 50)\r\nprint(f\"\u00c1rea total analisada: {ct_cerrado.total_area:,} hectares\")\r\nprint(f\"\u00c1rea que mudou: {ct_cerrado.total_change:,} hectares ({ct_cerrado.total_change/ct_cerrado.total_area*100:.1f}%)\")\r\nprint(f\"Taxa de mudan\u00e7a anual: {results_cerrado.interval.annual_change_rate:.2f}%\")\r\n\r\nprint(\"\r\n\ud83d\udd04 Principais Transi\u00e7\u00f5es:\"      transitions = ct_cerrado.table.stack()\r\ntop_transitions = transitions[transitions > 0].sort_values(ascending=False).head(5)\r\n\r\nfor (from_class, to_class), area in top_transitions.items():\r\n    if from_class != to_class:\r\n        print(f\"  {from_class} \u2192 {to_class}: {area:,} hectares\")\r\n\r\n# Gerar visualiza\u00e7\u00f5es\r\nfrom landuse_intensity.sankey_visualization import plot_single_step_sankey\r\n\r\nplot_single_step_sankey(\r\n    ct_cerrado.table,\r\n    output_dir=\"cerrado_results\",\r\n    filename=\"cerrado_transitions\",\r\n    title=\"Transi\u00e7\u00f5es no Bioma Cerrado (2000-2020)\",\r\n    export_formats=['html', 'png', 'pdf']\r\n)\r\n\r\nprint(\"\r\n\u2705 Relat\u00f3rio e visualiza\u00e7\u00f5es salvos em: cerrado_results/\"  print(\"\ud83c\udf10 Arquivo interativo: cerrado_results/cerrado_transitions.html\")\r\n```\r\n\r\n---\r\n\r\n## \ud83d\udd27 Solu\u00e7\u00e3o de Problemas\r\n\r\n### Erro: \"M\u00f3dulo n\u00e3o encontrado\"\r\n\r\n```python\r\n# Verificar instala\u00e7\u00e3o\r\nimport landuse_intensity as lui\r\nprint(\"Vers\u00e3o:\", lui.__version__)\r\n\r\n# Se n\u00e3o funcionar, reinstalar\r\npip uninstall landuse-intensity-analysis\r\npip install landuse-intensity-analysis\r\n```\r\n\r\n### Erro: \"Dados inv\u00e1lidos\"\r\n\r\n```python\r\n# Validar dados antes da an\u00e1lise\r\nfrom landuse_intensity.utils import validate_raster_data\r\n\r\nis_valid, message = validate_raster_data(raster_t1, raster_t2)\r\nif not is_valid:\r\n    print(f\"Erro nos dados: {message}\")\r\n```\r\n\r\n### Performance com Grandes Rasters\r\n\r\n```python\r\n# Para rasters muito grandes, processe em blocos\r\nfrom landuse_intensity.utils import process_raster_in_chunks\r\n\r\nresults = process_raster_in_chunks(\r\n    raster_t1, raster_t2,\r\n    chunk_size=(1000, 1000),\r\n    overlap=50\r\n)\r\n```\r\n\r\n---\r\n\r\n## \ud83d\udcda Refer\u00eancias\r\n\r\n### Metodologia\r\n\r\n- **Aldwaik, S. Z., & Pontius Jr, R. G. (2012).** Intensity analysis to unify measurements of size and stationarity of land changes by interval, category, and transition. *Landscape and Urban Planning*, 106(1), 103-114.\r\n\r\n- **Pontius Jr, R. G., & Millones, M. (2011).** Death to Kappa: birth of quantity disagreement and allocation disagreement for accuracy assessment. *International Journal of Remote Sensing*, 32(15), 4407-4429.\r\n\r\n### Implementa\u00e7\u00e3o\r\n\r\n- **Documenta\u00e7\u00e3o Oficial**: [Read the Docs](https://landuse-intensity-analysis.readthedocs.io/)\r\n- **Reposit\u00f3rio GitHub**: [C\u00f3digo Fonte](https://github.com/ils15/LandUse-Intensity-Analysis)\r\n- **Exemplos**: Pasta `examples/` no reposit\u00f3rio\r\n\r\n---\r\n\r\n## \ud83e\udd1d Contribui\u00e7\u00e3o\r\n\r\nContribui\u00e7\u00f5es s\u00e3o bem-vindas!\r\n\r\n1. Fork o projeto\r\n2. Crie uma branch para sua feature (`git checkout -b feature/nova-feature`)\r\n3. Commit suas mudan\u00e7as (`git commit -am 'Adiciona nova feature'`)\r\n4. Push para a branch (`git push origin feature/nova-feature`)\r\n5. Abra um Pull Request\r\n\r\n---\r\n\r\n## \ud83d\udcc4 Licen\u00e7a\r\n\r\nEste projeto est\u00e1 licenciado sob a Licen\u00e7a MIT - veja o arquivo [LICENSE](LICENSE) para detalhes.\r\n\r\n---\r\n\r\n## \ud83c\udd98 Suporte\r\n\r\n**Precisa de ajuda?**\r\n\r\n1. \ud83d\udcd6 **Documenta\u00e7\u00e3o**: Leia os exemplos na pasta `examples/`\r\n2. \ud83d\udc1b **Issues**: [GitHub Issues](https://github.com/ils15/LandUse-Intensity-Analysis/issues)\r\n3. \ud83d\udcac **Discuss\u00f5es**: [GitHub Discussions](https://github.com/ils15/LandUse-Intensity-Analysis/discussions)\r\n4. \ud83d\udce7 **Email**: Para quest\u00f5es espec\u00edficas\r\n\r\n---\r\n\r\n> Desenvolvido com \u2764\ufe0f para a comunidade de ci\u00eancias ambientais e geotecnologia\r\n\r\n**Vers\u00e3o Atual**: 2.0.3 | **Python**: 3.8+ | **Mantenedor**: [ils15](https://github.com/ils15)\r\n\r\n## \ud83c\udf1f What does it do?\r\n\r\nTransform your land cover raster data into meaningful insights about environmental change:\r\n\r\n1. **Quantify Changes**: Calculate transition matrices and area statistics from multi-temporal raster data\r\n2. **Intensity Analysis**: Apply the proven Pontius-Aldwaik methodology for interval, category, and transition-level analysis\r\n3. **Rich Visualizations**: Create publication-ready Sankey diagrams, heatmaps, spatial maps, and statistical plots\r\n4. **Spatial Analysis**: Process GeoTIFF files with built-in raster handling and spatial change detection\r\n\r\n## \u2728 Key Features\r\n\r\n- \ud83d\udd2c **Scientific Rigor**: Implements the established Pontius-Aldwaik intensity analysis methodology\r\n- \ud83d\udcca **Rich Visualizations**: Sankey diagrams, transition matrices, spatial maps, and statistical plots using matplotlib and plotly\r\n- \ud83d\uddfa\ufe0f **Spatial Support**: Direct processing of GeoTIFF files and numpy arrays\r\n- \ud83c\udfaf **Object-Oriented Design**: Clean API with `ContingencyTable`, `IntensityAnalyzer`, and `MultiStepAnalyzer` classes\r\n- \ud83d\udcc8 **Multi-temporal Analysis**: Support for analyzing changes across multiple time periods\r\n- \ud83d\udd27 **Comprehensive Toolkit**: Complete suite of utility functions for data processing and validation\r\n\r\n## \ud83d\ude80 Installation\r\n\r\n```bash\r\npip install landuse-intensity-analysis\r\n```\r\n\r\n## \ud83d\udcd6 Quick Start\r\n\r\n### Basic Analysis Example\r\n\r\n```python\r\nimport numpy as np\r\nimport landuse_intensity as lui\r\n\r\n# Step 1: Create contingency table from rasters\r\n# Example with 2 time periods and 3 land use classes\r\nraster_t1 = np.array([[1, 1, 2], [1, 2, 3], [2, 3, 3]])  # Time 1\r\nraster_t2 = np.array([[1, 2, 2], [2, 2, 3], [3, 3, 3]])  # Time 2\r\n\r\n# Create contingency table\r\nct = lui.ContingencyTable.from_rasters(\r\n    raster_t1, raster_t2, \r\n    labels1=['Forest', 'Agriculture', 'Urban', 'Water'],\r\n    labels2=['Forest', 'Agriculture', 'Urban', 'Water']\r\n)\r\n\r\n# Step 2: Run intensity analysis\r\nanalyzer = lui.IntensityAnalyzer(ct)\r\nresults = analyzer.full_analysis()\r\n\r\n# Step 3: Display results\r\nprint(\"Contingency Table:\")\r\nprint(ct.table)\r\nprint(f\"\\nTotal Change: {ct.total_change} pixels\")\r\nprint(f\"Persistence: {ct.persistence} pixels\")\r\n\r\n# Step 4: Create visualizations\r\nfrom landuse_intensity import visualization as viz\r\n\r\n# Sankey diagram\r\nviz.plot_single_step_sankey(\r\n    ct.table, \r\n    title=\"Land Use Transitions\",\r\n    save_path=\"sankey_diagram.html\"\r\n)\r\n\r\n# Transition matrix heatmap\r\nviz.plot_transition_matrix_heatmap(\r\n    ct.table,\r\n    title=\"Land Use Transition Matrix\",\r\n    save_path=\"transition_matrix.png\"\r\n)\r\n```\r\n\r\n### Working with Real Raster Files\r\n\r\n```python\r\nimport landuse_intensity as lui\r\n\r\n# Load raster data\r\nraster1, metadata1 = lui.read_raster(\"land_cover_2000.tif\")\r\nraster2, metadata2 = lui.read_raster(\"land_cover_2020.tif\")\r\n\r\n# Create contingency table\r\ncontingency_df = lui.raster_to_contingency_table(\r\n    raster1, raster2,\r\n    class_names=['Forest', 'Agriculture', 'Urban', 'Water']\r\n)\r\n\r\n# Initialize analysis\r\nct = lui.ContingencyTable(contingency_df)\r\nanalyzer = lui.IntensityAnalyzer(ct)\r\n\r\n# Perform complete analysis\r\nresults = analyzer.analyze()\r\nprint(\"Interval Level Analysis:\", results['interval'])\r\nprint(\"Category Level Analysis:\", results['category'])\r\n```\r\n\r\n### Multi-Temporal Analysis\r\n\r\n```python\r\nimport landuse_intensity as lui\r\n\r\n# Load multiple time periods\r\nrasters = [\r\n    lui.read_raster(\"land_cover_1990.tif\")[0],\r\n    lui.read_raster(\"land_cover_2000.tif\")[0], \r\n    lui.read_raster(\"land_cover_2010.tif\")[0],\r\n    lui.read_raster(\"land_cover_2020.tif\")[0]\r\n]\r\n\r\ntime_labels = ['1990', '2000', '2010', '2020']\r\n\r\n# Multi-step analysis\r\nmulti_analyzer = lui.MultiStepAnalyzer(rasters, time_labels)\r\nmulti_results = multi_analyzer.analyze_all_steps()\r\n\r\nprint(\"Multi-step Analysis Results:\")\r\nfor step, result in multi_results.items():\r\n    print(f\"{step}: {result['interval']['annual_change_rate']:.2f}% annual change\")\r\n```\r\n\r\n## \ufffd Complete API Reference\r\n\r\n### Core Classes\r\n\r\n#### ContingencyTable\r\n\r\nMain class for handling transition matrices:\r\n\r\n```python\r\n# Create from rasters\r\nct = lui.ContingencyTable.from_rasters(raster1, raster2, labels1, labels2)\r\n\r\n# Create from existing data  \r\nct = lui.ContingencyTable(dataframe_or_array)\r\n\r\n# Properties\r\nct.table              # Access transition matrix\r\nct.total_area        # Total number of pixels/area\r\nct.persistence       # Unchanged pixels\r\nct.total_change      # Changed pixels\r\nct.validate()        # Validate table structure\r\n```\r\n\r\n#### IntensityAnalyzer\r\nImplements Pontius-Aldwaik intensity analysis:\r\n\r\n```python\r\nanalyzer = lui.IntensityAnalyzer(contingency_table)\r\n\r\n# Analysis methods\r\nanalyzer.analyze_interval_level()    # Overall change intensity\r\nanalyzer.analyze_category_level()    # Class-specific gains/losses  \r\nanalyzer.analyze_transition_level(from_class, to_class)  # Transition intensity\r\nanalyzer.analyze()                   # Complete analysis\r\nanalyzer.full_analysis()            # Returns AnalysisResults object\r\n```\r\n\r\n#### MultiStepAnalyzer\r\nFor multi-temporal analysis:\r\n\r\n```python\r\nanalyzer = lui.MultiStepAnalyzer(raster_list, time_labels)\r\n\r\nanalyzer.analyze_all_steps()         # Step-by-step analysis\r\nanalyzer.analyze_overall_change()    # Overall change summary\r\nanalyzer.compare_step_vs_overall()   # Compare step vs overall rates\r\n```\r\n\r\n#### ChangeAnalyzer\r\nFor spatial change detection:\r\n\r\n```python\r\nchange_analyzer = lui.ChangeAnalyzer(raster1, raster2)\r\n\r\nchange_analyzer.analyze()            # Basic change detection\r\nchange_analyzer.detect_hotspots()    # Change hotspot detection\r\nchange_analyzer.create_change_map()  # Spatial change mapping\r\n```\r\n\r\n### Visualization Functions\r\n\r\n#### Graph Visualizations\r\nFrom `landuse_intensity.graph_visualization`:\r\n\r\n```python\r\nfrom landuse_intensity import graph_visualization as gv\r\n\r\n# Sankey diagrams\r\ngv.plot_single_step_sankey(\r\n    contingency_table, \r\n    title=\"Land Use Transitions\",\r\n    save_path=\"sankey.html\"\r\n)\r\n\r\n# Transition matrix heatmaps\r\ngv.plot_transition_matrix_heatmap(\r\n    contingency_table,\r\n    title=\"Transition Matrix\",\r\n    save_path=\"heatmap.png\"\r\n)\r\n\r\n# Bar plots for LULC analysis\r\ngv.plot_barplot_lulc(\r\n    lulc_data,\r\n    title=\"Land Use Areas\",\r\n    save_path=\"barplot.png\"\r\n)\r\n\r\n# Gain/Loss analysis\r\ngv.plot_gain_loss_analysis(\r\n    contingency_table,\r\n    title=\"Gain/Loss Analysis\"\r\n)\r\n\r\n# Accuracy assessment\r\ngv.plot_accuracy_assessment(\r\n    observed, predicted,\r\n    save_path=\"accuracy.png\"\r\n)\r\n\r\n# Confusion matrix\r\ngv.plot_confusion_matrix(\r\n    true_labels, predicted_labels\r\n)\r\n```\r\n\r\n#### Spatial Visualizations  \r\nFrom `landuse_intensity.map_visualization`:\r\n\r\n```python\r\nfrom landuse_intensity import map_visualization as mv\r\n\r\n# Spatial change maps\r\nmv.plot_spatial_change_map(\r\n    raster_t1, raster_t2,\r\n    title=\"Land Use Change Map\",\r\n    save_path=\"change_map.png\"\r\n)\r\n\r\n# Multi-temporal maps\r\nmv.plot_multi_temporal_maps(\r\n    raster_list, time_labels,\r\n    title=\"Land Use Over Time\"\r\n)\r\n\r\n# Change detection\r\nmv.plot_change_detection_map(\r\n    raster_t1, raster_t2,\r\n    title=\"Change Detection\"\r\n)\r\n\r\n# Interactive maps\r\nmv.plot_interactive_map(\r\n    raster_data, coordinates,\r\n    save_path=\"interactive_map.html\"\r\n)\r\n\r\n# Elevation models\r\nmv.plot_elevation_model(\r\n    elevation_raster,\r\n    title=\"Digital Elevation Model\"\r\n)\r\n```\r\n\r\n#### Advanced Visualizations\r\nFrom `landuse_intensity.visualization`:\r\n\r\n```python\r\nfrom landuse_intensity import visualization as viz\r\n\r\n# Intensity analysis plots\r\nviz.plot_intensity_analysis(\r\n    intensity_results,\r\n    title=\"Pontius Intensity Analysis\"\r\n)\r\n\r\n# Multi-step Sankey\r\nviz.plot_multi_step_sankey(\r\n    transitions_list,\r\n    time_labels=time_labels\r\n)\r\n\r\n# Spatial change with persistence\r\nviz.plot_persistence_map(\r\n    raster_t1, raster_t2,\r\n    title=\"Persistence Analysis\"\r\n)\r\n\r\n# Temporal land change\r\nviz.plot_temporal_land_change(\r\n    raster_list, time_labels,\r\n    save_path=\"temporal_change.png\"\r\n)\r\n\r\n# Change frequency mapping\r\nviz.plot_change_frequency_map(\r\n    raster_list,\r\n    title=\"Change Frequency Analysis\"\r\n)\r\n```\r\n\r\n### Utility Functions\r\n\r\n#### Data Processing\r\n```python\r\nimport landuse_intensity as lui\r\n\r\n# Demo data generation\r\nraster_t1, raster_t2 = lui.demo_landscape()\r\n\r\n# Data validation\r\nis_valid = lui.validate_data(raster_data)\r\n\r\n# Area calculations\r\narea_matrix = lui.calculate_area_matrix(contingency_table, pixel_area=900)\r\n\r\n# Change summary\r\nsummary = lui.get_change_summary(contingency_table)\r\n\r\n# Area formatting\r\nlabel = lui.format_area_label(1500.5, units=\"hectares\")\r\n\r\n# Transition naming\r\nnames = lui.create_transition_names(\r\n    from_classes=['Forest', 'Agriculture'], \r\n    to_classes=['Urban', 'Water']\r\n)\r\n```\r\n\r\n#### Image Processing\r\n```python\r\nimport landuse_intensity as lui\r\n\r\n# Create contingency table from rasters\r\nct = lui.create_contingency_table(raster1, raster2, labels=['Forest', 'Urban'])\r\n\r\n# Calculate change map\r\nchange_map = lui.calculate_change_map(raster_t1, raster_t2)\r\n\r\n# Apply majority filter  \r\nfiltered = lui.apply_majority_filter(raster, window_size=3)\r\n\r\n# Calculate patch metrics\r\nmetrics = lui.calculate_patch_metrics(raster, class_value=1)\r\n\r\n# Resample raster\r\nresampled = lui.resample_raster(raster, target_shape=(100, 100))\r\n\r\n# Align rasters\r\naligned1, aligned2 = lui.align_rasters(raster1, raster2)\r\n\r\n# Validate raster\r\nis_valid = lui.validate_raster(raster)\r\n\r\n# Mask raster\r\nmasked = lui.mask_raster(raster, mask, nodata_value=-9999)\r\n```\r\n\r\n#### Raster Handling\r\n```python\r\nimport landuse_intensity as lui\r\n\r\n# Read raster file\r\nraster_data, metadata = lui.read_raster(\"landcover.tif\")\r\n\r\n# Write raster file\r\nlui.write_raster(\r\n    raster_data, \"output.tif\", \r\n    metadata=metadata,\r\n    nodata_value=-9999\r\n)\r\n\r\n# Convert rasters to contingency table\r\ncontingency_df = lui.raster_to_contingency_table(\r\n    raster1, raster2,\r\n    class_names=['Forest', 'Agriculture', 'Urban']\r\n)\r\n\r\n# Load demo data\r\ndemo_raster1, demo_raster2 = lui.load_demo_data()\r\n\r\n# Raster summary statistics\r\nsummary = lui.raster_summary(raster)\r\n\r\n# Reclassify raster\r\nreclassified = lui.reclassify_raster(\r\n    raster, \r\n    reclass_dict={1: 10, 2: 20, 3: 30}\r\n)\r\n```\r\n\r\n## \ud83d\udcca Analysis Functions\r\n\r\n### Main Analysis Function\r\n```python\r\n# One-step comprehensive analysis\r\nresults = lui.analyze_land_use_change(\r\n    raster1=raster_t1,\r\n    raster2=raster_t2, \r\n    area_calculation=True,\r\n    intensity_analysis=True,\r\n    save_tables=True,\r\n    output_dir=\"./results/\"\r\n)\r\n```\r\n\r\n## \ud83c\udfaf Complete Example: Real Dataset Analysis\r\n\r\n```python\r\nimport landuse_intensity as lui\r\nimport numpy as np\r\n\r\n# 1. Load real raster data\r\nraster_2000, meta_2000 = lui.read_raster(\"cerrado_2000.tif\")\r\nraster_2010, meta_2010 = lui.read_raster(\"cerrado_2010.tif\") \r\nraster_2020, meta_2020 = lui.read_raster(\"cerrado_2020.tif\")\r\n\r\n# 2. Create contingency tables\r\nct_2000_2010 = lui.ContingencyTable.from_rasters(\r\n    raster_2000, raster_2010,\r\n    labels1=['Forest', 'Savanna', 'Agriculture', 'Pasture', 'Urban'],\r\n    labels2=['Forest', 'Savanna', 'Agriculture', 'Pasture', 'Urban']\r\n)\r\n\r\nct_2010_2020 = lui.ContingencyTable.from_rasters(\r\n    raster_2010, raster_2020,\r\n    labels1=['Forest', 'Savanna', 'Agriculture', 'Pasture', 'Urban'],\r\n    labels2=['Forest', 'Savanna', 'Agriculture', 'Pasture', 'Urban']\r\n)\r\n\r\n# 3. Intensity analysis\r\nanalyzer_2000_2010 = lui.IntensityAnalyzer(ct_2000_2010)\r\nanalyzer_2010_2020 = lui.IntensityAnalyzer(ct_2010_2020)\r\n\r\nresults_2000_2010 = analyzer_2000_2010.analyze()\r\nresults_2010_2020 = analyzer_2010_2020.analyze()\r\n\r\n# 4. Multi-temporal analysis\r\nmulti_analyzer = lui.MultiStepAnalyzer(\r\n    [raster_2000, raster_2010, raster_2020],\r\n    ['2000', '2010', '2020']\r\n)\r\nmulti_results = multi_analyzer.analyze_all_steps()\r\n\r\n# 5. Create visualizations\r\nfrom landuse_intensity import graph_visualization as gv\r\nfrom landuse_intensity import map_visualization as mv\r\n\r\n# Sankey diagrams for each period\r\ngv.plot_single_step_sankey(\r\n    ct_2000_2010.table,\r\n    title=\"Cerrado Land Use Transitions 2000-2010\",\r\n    save_path=\"sankey_2000_2010.html\"\r\n)\r\n\r\ngv.plot_single_step_sankey(\r\n    ct_2010_2020.table, \r\n    title=\"Cerrado Land Use Transitions 2010-2020\",\r\n    save_path=\"sankey_2010_2020.html\"\r\n)\r\n\r\n# Spatial change maps\r\nmv.plot_spatial_change_map(\r\n    raster_2000, raster_2020,\r\n    title=\"Cerrado Land Use Change 2000-2020\",\r\n    save_path=\"cerrado_change_map.png\"\r\n)\r\n\r\n# Multi-temporal maps\r\nmv.plot_multi_temporal_maps(\r\n    [raster_2000, raster_2010, raster_2020],\r\n    ['2000', '2010', '2020'],\r\n    title=\"Cerrado Land Use Evolution\"\r\n)\r\n\r\n# 6. Export results\r\nprint(\"=== ANALYSIS RESULTS ===\")\r\nprint(f\"Period 2000-2010:\")\r\nprint(f\"  Annual change rate: {results_2000_2010['interval']['annual_change_rate']:.2f}%\")\r\nprint(f\"  Total change: {ct_2000_2010.total_change} pixels\")\r\n\r\nprint(f\"Period 2010-2020:\")  \r\nprint(f\"  Annual change rate: {results_2010_2020['interval']['annual_change_rate']:.2f}%\")\r\nprint(f\"  Total change: {ct_2010_2020.total_change} pixels\")\r\n\r\n# Export contingency tables\r\nct_2000_2010.table.to_csv(\"contingency_2000_2010.csv\")\r\nct_2010_2020.table.to_csv(\"contingency_2010_2020.csv\")\r\n```\r\n\r\n## \ud83d\udcda References\r\n\r\nThis library implements the Pontius-Aldwaik intensity analysis methodology:\r\n\r\n- Aldwaik, S. Z., & Pontius Jr, R. G. (2012). Intensity analysis to unify measurements of size and stationarity of land changes by interval, category, and transition. *Landscape and Urban Planning*, 106(1), 103-114.\r\n\r\n- Pontius Jr, R. G., & Millones, M. (2011). Death to Kappa: birth of quantity disagreement and allocation disagreement for accuracy assessment. *International Journal of Remote Sensing*, 32(15), 4407-4429.\r\n\r\n## \ud83d\udcc4 License\r\n\r\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.\r\n\r\n## \ud83e\udd1d Contributing\r\n\r\nContributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.\r\n\r\n## \ud83d\udcee Support\r\n\r\nIf you encounter any issues or have questions:\r\n\r\n1. Check the examples in the `examples/` directory\r\n2. Read the documentation\r\n3. Open an issue on GitHub\r\n\r\n## \ud83c\udfaf Version Information\r\n\r\n- **Current Version**: 2.0.3\r\n- **Python Requirements**: Python 3.8+\r\n- **Key Dependencies**: numpy, pandas, matplotlib, plotly, rasterio\r\n\r\n---\r\n\r\n> Made with \u2764\ufe0f for the geospatial and environmental science community\r\n\r\n- **Smart Detection**: No need to manually specify analysis type\r\n- **Methodology Compatible**: Follows established methodology\r\n- **Flexible**: Override auto-detection when needed\r\n- **Unified Interface**: Single function for all analysis types\r\n\r\n### Raster Stacking and Year Detection\r\n\r\n#### Raster Stacking Options\r\n\r\n**1. Automatic Directory Loading:**\r\n\r\n```python\r\nfrom landuse_intensity.raster import load_rasters\r\n\r\n# Load all .tif files from directory\r\nrasters = load_rasters(\"data/landuse/\")\r\n# Automatically finds and stacks: landuse_1990.tif, landuse_2000.tif, landuse_2010.tif\r\n```\r\n\r\n**2. Manual File Selection:**\r\n\r\n```python\r\n# Load specific files in custom order\r\nfiles = [\"landuse_1990.tif\", \"landuse_2005.tif\", \"landuse_2010.tif\"]\r\nrasters = load_rasters(files)\r\n```\r\n\r\n## Scientific Background\r\n\r\nThis library implements the Pontius-Aldwaik intensity analysis methodology, which provides a comprehensive framework for understanding land use change patterns. The methodology distinguishes between:\r\n\r\n- **Quantity of change**: How much land changed category\r\n- **Exchange**: Land that would have changed even if proportions remained constant\r\n- **Shift**: Land that changed due to systematic transitions\r\n\r\n## API Reference\r\n\r\n### Main Classes\r\n\r\n#### `ContingencyTable`\r\n\r\nMain class for creating and managing transition matrices.\r\n\r\n**Methods:**\r\n\r\n- `from_rasters()`: Create contingency table from raster data\r\n- `validate()`: Validate table data integrity\r\n- `get_summary_stats()`: Get statistical summary\r\n- `get_transition_matrix()`: Get transition matrix representation\r\n\r\n#### `IntensityAnalyzer`\r\n\r\nClass for performing Pontius-Aldwaik intensity analysis.\r\n\r\n**Methods:**\r\n\r\n- `analyze()`: Perform intensity analysis on contingency table\r\n- `full_analysis()`: Complete analysis with all metrics\r\n- `get_category_analysis()`: Category-level intensity analysis\r\n- `get_transition_analysis()`: Transition-level intensity analysis\r\n\r\n### Data Format\r\n\r\nThe library expects land use data in numpy arrays or pandas DataFrames:\r\n\r\n```python\r\n# Raster data (numpy arrays)\r\nraster_1990 = np.array([[1, 1, 2], [1, 2, 3], [2, 3, 3]])\r\nraster_2000 = np.array([[1, 2, 2], [2, 2, 3], [3, 3, 3]])\r\n\r\n# Or pandas DataFrame\r\ncontingency_df = pd.DataFrame({\r\n    'Forest->Forest': [100, 0, 0],\r\n    'Forest->Agriculture': [20, 0, 0],\r\n    'Agriculture->Agriculture': [0, 80, 0]\r\n})\r\n```\r\n\r\n## Visualization Gallery\r\n\r\nThe library provides several types of visualizations:\r\n\r\n- **Intensity Maps**: Spatial distribution of land use intensity\r\n- **Transition Matrices**: Category transition probabilities\r\n- **Time Series Plots**: Temporal evolution of land use patterns\r\n- **Chord Diagrams**: Flow visualization between categories\r\n- **Sankey Diagrams**: Flow-based transition visualization\r\n\r\n## Advanced Usage\r\n\r\n### Working with Large Datasets\r\n\r\n```python\r\n# For large raster datasets, consider memory usage\r\nimport numpy as np\r\nfrom landuse_intensity import ContingencyTable\r\n\r\n# Process in chunks for very large rasters\r\ndef process_large_raster(raster1, raster2, chunk_size=1000):\r\n    height, width = raster1.shape\r\n    results = []\r\n    \r\n    for i in range(0, height, chunk_size):\r\n        for j in range(0, width, chunk_size):\r\n            chunk1 = raster1[i:i+chunk_size, j:j+chunk_size]\r\n            chunk2 = raster2[i:i+chunk_size, j:j+chunk_size]\r\n            \r\n            ct = ContingencyTable.from_rasters(chunk1, chunk2)\r\n            results.append(ct)\r\n    \r\n    return results\r\n```\r\n\r\n### Custom Analysis Parameters\r\n\r\n```python\r\n# Customize analysis with specific parameters\r\nfrom landuse_intensity import IntensityAnalyzer\r\n\r\n# Create analyzer with custom settings\r\nanalyzer = IntensityAnalyzer()\r\n\r\n# Perform analysis with specific options\r\nresults = analyzer.analyze(\r\n    contingency_table=ct,\r\n    include_interval=True,\r\n    include_category=True,\r\n    include_transition=True\r\n)\r\n```\r\n\r\n### Spatial Analysis\r\n\r\n```python\r\n# Load geospatial data\r\nimport rasterio\r\nimport xarray as xr\r\n\r\nwith rasterio.open('land_use_1990.tif') as src:\r\n    data_1990 = src.read(1)\r\n\r\nwith rasterio.open('land_use_2000.tif') as src:\r\n    data_2000 = src.read(1)\r\n\r\n# Perform spatial intensity analysis\r\nspatial_results = analyzer.spatial_intensity_analysis(\r\n    data_1990, data_2000,\r\n    transform=src.transform\r\n)\r\n```\r\n\r\n## \ud83d\udcda Complete Documentation\r\n\r\n## Usage\r\n\r\n### \ud83d\udd27 Key Features\r\n\r\n- **Raster Loading**: Multiple methods (automatic, manual, dataset)\r\n- **Year Detection**: Automatic year extraction from filenames\r\n- **Contingency Tables**: Transition matrix generation\r\n- **Intensity Analysis**: Pontius-Aldwaik methodology\r\n- **Visualizations**: Modern interactive plots\r\n- **Change Maps**: Spatial analysis and mapping\r\n- **Export Options**: CSV, JSON, HTML formats\r\n\r\n### \ud83d\udccb Complete Analysis Workflow\r\n\r\n```python\r\n# 1. Load raster data\r\nfrom landuse_intensity import read_raster\r\nraster1, meta1 = read_raster(\"landuse_1990.tif\")\r\nraster2, meta2 = read_raster(\"landuse_2000.tif\")\r\n\r\n# 2. Generate contingency table\r\nfrom landuse_intensity import ContingencyTable\r\nct = ContingencyTable.from_rasters(raster1, raster2)\r\n\r\n# 3. Perform intensity analysis\r\nfrom landuse_intensity import IntensityAnalyzer\r\nanalyzer = IntensityAnalyzer(ct)\r\nresults = analyzer.full_analysis()\r\n\r\n# 4. Create visualizations\r\nfrom landuse_intensity import visualization as viz\r\nviz.plot_single_step_sankey(ct.table, title=\"Land Use Transitions\")\r\nviz.plot_transition_matrix_heatmap(ct.table, title=\"Transition Matrix\")\r\n\r\n# 5. Generate change maps\r\nfrom landuse_intensity import image_processing\r\nchange_map = image_processing.calculate_change_map(raster1, raster2)\r\n\r\n# 6. Export results\r\nct.table.to_csv(\"contingency_table.csv\")\r\n```\r\n\r\n## Examples\r\n\r\nThe library includes comprehensive examples demonstrating various land use analysis capabilities:\r\n\r\n```python\r\n# Basic intensity analysis example\r\nimport numpy as np\r\nimport landuse_intensity as lui\r\n\r\n# Generate demo data\r\nraster_t1, raster_t2 = lui.demo_landscape()\r\n\r\n# Create contingency table\r\nct = lui.ContingencyTable.from_rasters(raster_t1, raster_t2)\r\n\r\n# Perform intensity analysis\r\nanalyzer = lui.IntensityAnalyzer(ct)\r\nresults = analyzer.full_analysis()\r\n\r\n# Create visualizations\r\nimport landuse_intensity.visualization as viz\r\nviz.plot_single_step_sankey(ct.table, title=\"Land Use Transitions\")\r\nviz.plot_transition_matrix_heatmap(ct.table, title=\"Transition Matrix\")\r\n\r\nprint(f\"Analysis completed! Total change: {ct.total_change} pixels\")\r\n```\r\n\r\n## Contributing\r\n\r\nWe welcome contributions! Please see our GitHub repository for details on contributing to the project.\r\n\r\n## License\r\n\r\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.\r\n\r\n## Citation\r\n\r\nIf you use this library in your research, please cite:\r\n\r\n```bibtex\r\n@software{landuse_intensity_analysis,\r\n  title = {Land Use Intensity Analysis},\r\n  author = {LandUse Intensity Analysis Contributors},\r\n  url = {https://github.com/your-repo/landuse-intensity-analysis},\r\n  version = {1.0.3a1},\r\n  date = {2024}\r\n}\r\n```\r\n\r\n## Support\r\n\r\n- **Documentation**: [Read the Docs](https://landuse-intensity-analysis.readthedocs.io/)\r\n- **Issues**: [GitHub Issues](https://github.com/your-repo/landuse-intensity-analysis/issues)\r\n- **Discussions**: [GitHub Discussions](https://github.com/your-repo/landuse-intensity-analysis/discussions)\r\n\r\n## Related Projects\r\n\r\n- [Pontius Research Group](https://www.clarku.edu/departments/geography/pontius/): Original methodology developers\r\n- [GDAL](https://gdal.org/): Geospatial data processing\r\n- [Rasterio](https://rasterio.readthedocs.io/): Python geospatial raster processing\r\n- [Xarray](https://xarray.pydata.org/): N-dimensional arrays for Python\r\n\r\n<!-- Test commit for workflow validation -->\r\n",
    "bugtrack_url": null,
    "license": null,
    "summary": "Modernized Python library for scientifically rigorous land use change analysis with intelligent auto-detection, comprehensive customization, and streamlined processing pipeline. Features automatic year detection from filenames and complete configuration framework.",
    "version": "2.0.0a2",
    "project_urls": {
        "Bug Tracker": "https://github.com/ils15/LandUse-Intensity-Analysis/issues",
        "Changelog": "https://github.com/ils15/LandUse-Intensity-Analysis/blob/main/CHANGELOG.md",
        "Documentation": "https://landuse-intensity-analysis.readthedocs.io",
        "Homepage": "https://github.com/ils15/LandUse-Intensity-Analysis",
        "Repository": "https://github.com/ils15/LandUse-Intensity-Analysis"
    },
    "split_keywords": [
        "land-use",
        " intensity-analysis",
        " pontius",
        " aldwaik",
        " remote-sensing",
        " gis",
        " land-change",
        " spatial-analysis",
        " environmental-science"
    ],
    "urls": [
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "0be92eb349e69ec1f78c968ebefa330613eaad39d5e03ee664185021413281e3",
                "md5": "500bfe4f096991bc38ec1f4ff0a1ac1d",
                "sha256": "ddb30d353dea3018d00c9ea8575454f6560fff6d452d628e711465daa2f7a4b6"
            },
            "downloads": -1,
            "filename": "landuse_intensity_analysis-2.0.0a2-py3-none-any.whl",
            "has_sig": false,
            "md5_digest": "500bfe4f096991bc38ec1f4ff0a1ac1d",
            "packagetype": "bdist_wheel",
            "python_version": "py3",
            "requires_python": ">=3.8",
            "size": 60672,
            "upload_time": "2025-08-29T18:29:54",
            "upload_time_iso_8601": "2025-08-29T18:29:54.294298Z",
            "url": "https://files.pythonhosted.org/packages/0b/e9/2eb349e69ec1f78c968ebefa330613eaad39d5e03ee664185021413281e3/landuse_intensity_analysis-2.0.0a2-py3-none-any.whl",
            "yanked": false,
            "yanked_reason": null
        }
    ],
    "upload_time": "2025-08-29 18:29:54",
    "github": true,
    "gitlab": false,
    "bitbucket": false,
    "codeberg": false,
    "github_user": "ils15",
    "github_project": "LandUse-Intensity-Analysis",
    "github_not_found": true,
    "lcname": "landuse-intensity-analysis"
}