from qgis.processing import alg
import processing

@alg(name="alertas_em_ucs", label="Alertas em UCs", group="monitoramento",
     group_label="Monitoramento")
@alg.input(type=alg.SOURCE, name="ENTRADA", label="Camada de alertas")
@alg.input(type=alg.SOURCE, name="UCS", label="Limites das UCs")
@alg.input(type=alg.SINK, name="SAIDA", label="Alertas em UCs")
def alertas_em_ucs(instance, parameters, context, feedback, inputs):
    """Cruza os alertas com as UCs e mantém os atributos das duas camadas."""
    resultado = processing.run("native:intersection", {
        "INPUT": parameters["ENTRADA"], "OVERLAY": parameters["UCS"],
        "OUTPUT": parameters["SAIDA"]}, context=context, feedback=feedback)
    return {"SAIDA": resultado["OUTPUT"]}

CREATE OR REPLACE VIEW alertas_em_ucs AS
SELECT a.*, u.cnuc, u.nome_uc,
       ST_Intersection(a.geom, u.geom) AS geom_uc
FROM artigos.deter a
JOIN artigos.ucs u ON ST_Intersects(a.geom, u.geom);

import sys
import geopandas as gpd

entrada, ucs, saida = sys.argv[1:4]
alertas = gpd.read_file(entrada)
limites = gpd.read_file(ucs).to_crs(alertas.crs)
gpd.overlay(alertas, limites, how="intersection").to_file(saida)

python alertas_em_ucs.py deter.gpkg ucs.gpkg alertas_ucs.gpkg

import processing
G = "C:/dados/artigos.gpkg"

def rodar(alg, **p):
    p.setdefault("OUTPUT", "memory:")
    return processing.run(alg, p)["OUTPUT"]

# 0 e 1. UCs da Amazônia em metros, buffer de 3 km e diferença
ucs = rodar("native:extractbyexpression", INPUT=f"{G}|layername=ucs",
            EXPRESSION="regiao = 'Amazonia'")
ucs = rodar("native:fixgeometries", INPUT=ucs)
ucs_m = rodar("native:reprojectlayer", INPUT=ucs, TARGET_CRS="EPSG:5880")
faixa = rodar("native:buffer", INPUT=ucs_m, DISTANCE=3000, SEGMENTS=16, DISSOLVE=False)
entorno = rodar("native:difference", INPUT=faixa, OVERLAY=ucs_m)

# 2. Campo "local" e junção
interior = rodar("native:fieldcalculator", INPUT=ucs_m, FIELD_NAME="local",
                 FIELD_TYPE=2, FIELD_LENGTH=10, FORMULA="'interior'")
entorno = rodar("native:fieldcalculator", INPUT=entorno, FIELD_NAME="local",
                FIELD_TYPE=2, FIELD_LENGTH=10, FORMULA="'entorno'")
zonas = rodar("native:mergevectorlayers", LAYERS=[interior, entorno], CRS="EPSG:4674")
zonas = rodar("native:fixgeometries", INPUT=zonas)

# 3. Alertas corrigidos × zonas
deter = rodar("native:fixgeometries", INPUT=f"{G}|layername=deter")
cruzado = rodar("native:intersection", INPUT=deter, OVERLAY=zonas,
                OVERLAY_FIELDS=["cnuc", "nome_uc", "local"])
cruzado = rodar("native:deletecolumn", INPUT=cruzado, COLUMN=["fid"])  # veja a armadilha 3

# 4. Área em hectares e resumo
cruzado = rodar("native:fieldcalculator", INPUT=cruzado, FIELD_NAME="area_ha",
                FIELD_TYPE=0, FIELD_PRECISION=4,
                FORMULA="area(transform($geometry, 'EPSG:4674', 'ESRI:102033')) / 10000",
                OUTPUT="C:/dados/deter_interior_entorno.gpkg")
resumo = rodar("qgis:statisticsbycategories", INPUT=cruzado, VALUES_FIELD_NAME="area_ha",
               CATEGORIES_FIELD_NAME=["nome_uc", "local"])
QgsProject.instance().addMapLayers([zonas, resumo])

-- 1 e 2. Zonas: interior (a própria UC) e entorno (3 km menos todas as UCs)
CREATE TABLE artigos.zonas_ucs AS
WITH ucs AS (
    SELECT cnuc, nome_uc, ST_MakeValid(geom) AS geom
    FROM artigos.ucs
    WHERE regiao = 'Amazonia'
),
todas AS (
    SELECT ST_Union(geom) AS geom FROM ucs
)
SELECT cnuc, nome_uc, 'interior' AS local, geom
FROM ucs
UNION ALL
SELECT u.cnuc, u.nome_uc, 'entorno',
       ST_Multi(ST_Difference(ST_Buffer(u.geom::geography, 3000)::geometry, t.geom))
FROM ucs u, todas t;

CREATE INDEX ON artigos.zonas_ucs USING gist (geom);

-- 0 e 3. Alertas corrigidos × zonas
CREATE TABLE artigos.deter_interior_entorno AS
WITH deter AS (
    SELECT gid, classname, view_date, municipality,
           ST_CollectionExtract(ST_MakeValid(geom), 3) AS geom   -- 3 = só polígonos
    FROM artigos.deter
)
SELECT d.gid, d.classname, d.view_date, d.municipality, z.cnuc, z.nome_uc, z.local,
       ST_Intersection(d.geom, z.geom) AS geom
FROM deter d
JOIN artigos.zonas_ucs z ON ST_Intersects(d.geom, z.geom)
WHERE NOT ST_IsEmpty(d.geom);

-- 4. Área em hectares e resumo
ALTER TABLE artigos.deter_interior_entorno ADD COLUMN area_ha numeric;
UPDATE artigos.deter_interior_entorno SET area_ha = ST_Area(geom::geography) / 10000;

SELECT nome_uc, local, count(*) AS alertas, round(sum(area_ha), 1) AS area_ha
FROM artigos.deter_interior_entorno
GROUP BY nome_uc, local
ORDER BY nome_uc, local;

import geopandas as gpd
import pandas as pd

G = "dados/artigos.gpkg"
ucs = gpd.read_file(G, layer="ucs").query("regiao == 'Amazonia'")
deter = gpd.read_file(G, layer="deter")

# 0. Corrigir geometrias, descartando pedaços que viram linha ou ponto
def corrigir(gdf):
    gdf["geometry"] = gdf.make_valid(method="structure", keep_collapsed=False)
    return gdf[~gdf.is_empty]

ucs, deter = corrigir(ucs), corrigir(deter)

# 1. Entorno: faixa de 3 km (em metros, EPSG:5880) menos todas as UCs
ucs_m = ucs.to_crs(5880)
entorno = gpd.GeoDataFrame(ucs_m[["cnuc", "nome_uc"]],
                           geometry=ucs_m.buffer(3000).difference(ucs_m.union_all()),
                           crs=5880)

# 2. Zonas com o campo "local"
zonas = pd.concat([ucs_m[["cnuc", "nome_uc", "geometry"]].assign(local="interior"),
                   entorno.assign(local="entorno")])
zonas = gpd.GeoDataFrame(zonas, crs=5880).to_crs(deter.crs)

# 3. Interseção e área em hectares (projeção de área igual)
cruzado = gpd.overlay(deter, zonas, how="intersection", keep_geom_type=True)
cruzado["area_ha"] = cruzado.to_crs("ESRI:102033").area / 10_000
cruzado.to_file("dados/deter_interior_entorno.gpkg")

# 4. Tabela resumo
resumo = (cruzado.groupby(["nome_uc", "local"])
          .agg(alertas=("gid", "count"), area_ha=("area_ha", "sum"))
          .round(1).reset_index())
print(resumo)

import processing
G = "C:/dados/artigos.gpkg"

def rodar(alg, **p):
    p.setdefault("OUTPUT", "memory:")
    return processing.run(alg, p)["OUTPUT"]

partes = []
for bioma, camada, regiao in [("Amazônia", "prodes_amz", "Amazonia"),
                              ("Cerrado", "prodes_cerrado", "Cerrado")]:
    # 1. Desmatamento e geometrias corrigidas
    prodes = rodar("native:extractbyexpression", INPUT=f"{G}|layername={camada}",
                   EXPRESSION="upper(main_class) = 'DESMATAMENTO'")
    prodes = rodar("native:fixgeometries", INPUT=prodes)
    ucs = rodar("native:extractbyexpression", INPUT=f"{G}|layername=ucs",
                EXPRESSION=f"regiao = '{regiao}'")

    # 2 e 3. Interseção, área em hectares e bioma
    cruzado = rodar("native:intersection", INPUT=prodes, OVERLAY=ucs,
                    INPUT_FIELDS=["year"], OVERLAY_FIELDS=["cnuc", "nome_uc", "grupo"])
    cruzado = rodar("native:fieldcalculator", INPUT=cruzado, FIELD_NAME="area_ha",
                    FIELD_TYPE=0, FIELD_PRECISION=4,
                    FORMULA="area(transform($geometry, 'EPSG:4674', 'ESRI:102033')) / 10000")
    cruzado = rodar("native:fieldcalculator", INPUT=cruzado, FIELD_NAME="bioma",
                    FIELD_TYPE=2, FIELD_LENGTH=10, FORMULA=f"'{bioma}'")
    partes.append(cruzado)

prodes_ucs = rodar("native:mergevectorlayers", LAYERS=partes, CRS="EPSG:4674")

# 4. Soma por bioma, ano e UC; depois, só o último ano de cada bioma
por_uc = rodar("qgis:statisticsbycategories", INPUT=prodes_ucs, VALUES_FIELD_NAME="area_ha",
               CATEGORIES_FIELD_NAME=["bioma", "year", "nome_uc"])
ultimo = rodar("native:extractbyexpression", INPUT=por_uc,
               EXPRESSION='"year" = maximum("year", group_by:="bioma")')
for f in ultimo.getFeatures():
    print(f["bioma"], f["year"], f["nome_uc"], round(f["sum"], 1))

-- 1 a 3. Os dois biomas numa tabela só
DROP TABLE IF EXISTS artigos.prodes_ucs;
CREATE TABLE artigos.prodes_ucs AS
WITH prodes AS (
    SELECT 'Amazônia' AS bioma, 'Amazonia' AS regiao, year AS ano,
           ST_CollectionExtract(ST_MakeValid(geom), 3) AS geom
    FROM artigos.prodes_amz
    WHERE upper(main_class) = 'DESMATAMENTO'
    UNION ALL
    SELECT 'Cerrado', 'Cerrado', year,
           ST_CollectionExtract(ST_MakeValid(geom), 3)
    FROM artigos.prodes_cerrado
    WHERE upper(main_class) = 'DESMATAMENTO'
)
SELECT p.bioma, p.ano, u.cnuc, u.nome_uc, u.grupo,
       ST_Intersection(p.geom, u.geom) AS geom
FROM prodes p
JOIN artigos.ucs u ON u.regiao = p.regiao AND ST_Intersects(p.geom, u.geom)
WHERE NOT ST_IsEmpty(p.geom);

ALTER TABLE artigos.prodes_ucs ADD COLUMN area_ha numeric;
UPDATE artigos.prodes_ucs SET area_ha = ST_Area(geom::geography) / 10000;

-- 4a. Último ano de cada bioma, por UC
SELECT bioma, ano, nome_uc, grupo, count(*) AS poligonos, round(sum(area_ha), 1) AS area_ha
FROM artigos.prodes_ucs p
WHERE ano = (SELECT max(ano) FROM artigos.prodes_ucs q WHERE q.bioma = p.bioma)
GROUP BY bioma, ano, nome_uc, grupo
ORDER BY bioma, area_ha DESC;

-- 4b. Série histórica
SELECT ano,
       round(sum(area_ha) FILTER (WHERE bioma = 'Amazônia')) AS amazonia_ha,
       round(sum(area_ha) FILTER (WHERE bioma = 'Cerrado')) AS cerrado_ha
FROM artigos.prodes_ucs
GROUP BY ano
ORDER BY ano;

import geopandas as gpd
import pandas as pd

G = "dados/artigos.gpkg"
ucs = gpd.read_file(G, layer="ucs")

def corrigir(gdf):
    gdf["geometry"] = gdf.make_valid(method="structure", keep_collapsed=False)
    return gdf[~gdf.is_empty]

def prodes_em_ucs(camada, regiao, bioma):
    """Cruza uma camada do PRODES com as UCs de uma região e mede em hectares."""
    prodes = gpd.read_file(G, layer=camada)
    prodes = corrigir(prodes[prodes["main_class"].str.upper() == "DESMATAMENTO"])
    u = ucs[ucs["regiao"] == regiao][["cnuc", "nome_uc", "grupo", "geometry"]]
    x = gpd.overlay(prodes[["year", "geometry"]], u, how="intersection", keep_geom_type=True)
    x["area_ha"] = x.to_crs("ESRI:102033").area / 10_000
    return x.assign(bioma=bioma).rename(columns={"year": "ano"})

prodes_ucs = pd.concat([prodes_em_ucs("prodes_amz", "Amazonia", "Amazônia"),
                        prodes_em_ucs("prodes_cerrado", "Cerrado", "Cerrado")])

# 4a. Último ano de cada bioma, por UC
ultimo = prodes_ucs[prodes_ucs["ano"] == prodes_ucs.groupby("bioma")["ano"].transform("max")]
print(ultimo.groupby(["bioma", "ano", "nome_uc", "grupo"])
            .agg(poligonos=("area_ha", "size"), area_ha=("area_ha", "sum"))
            .round(1).sort_values("area_ha", ascending=False))

# 4b. Série histórica
print(prodes_ucs.pivot_table(index="ano", columns="bioma", values="area_ha",
                             aggfunc="sum").round())

BEGIN;
DELETE FROM artigos.prodes_ucs WHERE bioma = 'Amazônia' AND ano = 2025;
INSERT INTO artigos.prodes_ucs (bioma, ano, cnuc, nome_uc, grupo, geom, area_ha)
SELECT bioma, ano, cnuc, nome_uc, grupo, geom, area_ha
FROM artigos.prodes_ucs_novo            -- o mesmo cruzamento, só com o ano novo
WHERE bioma = 'Amazônia' AND ano = 2025;
COMMIT;

historico = gpd.read_file("dados/prodes_ucs_historico.gpkg")
ano, bioma = 2025, "Amazônia"
novos = prodes_ucs[(prodes_ucs["ano"] == ano) & (prodes_ucs["bioma"] == bioma)]
historico = pd.concat([historico[~((historico["ano"] == ano) & (historico["bioma"] == bioma))],
                       novos])
historico.to_file("dados/prodes_ucs_historico.gpkg")

import os, tempfile, urllib.request
from datetime import datetime, timedelta, timezone
import processing

G = "C:/dados/artigos.gpkg"
url = ("https://dataserver-coids.inpe.br/queimadas/queimadas/focos/csv/diario/"
       "Brasil/focos_diario_br_{}.csv")

def rodar(alg, **p):
    p.setdefault("OUTPUT", "memory:")
    return processing.run(alg, p)["OUTPUT"]

# 1 e 2. Baixar os três dias e abrir como camada de pontos (texto delimitado)
agora = datetime.now(timezone.utc)
camadas = []
for i in range(3):
    dia = (agora - timedelta(days=i)).strftime("%Y%m%d")
    csv = os.path.join(tempfile.gettempdir(), f"focos_{dia}.csv")
    urllib.request.urlretrieve(url.format(dia), csv)
    uri = (f"file:///{csv}?delimiter=,&xField=lon&yField=lat&crs=EPSG:4674"
           "&field=data_hora_gmt:text")
    camadas.append(QgsVectorLayer(uri, f"focos_{dia}", "delimitedtext"))
focos = rodar("native:mergevectorlayers", LAYERS=camadas, CRS="EPSG:4674")

# 3. Últimas 48 horas (texto no formato AAAA-MM-DD HH:MM:SS se compara como data)
corte = (agora - timedelta(hours=48)).strftime("%Y-%m-%d %H:%M:%S")
focos = rodar("native:extractbyexpression", INPUT=focos,
              EXPRESSION=f"\"data_hora_gmt\" >= '{corte}'")

# 4. UC de cada foco (predicado 5 = "está dentro")
focos_ucs = rodar("native:joinattributesbylocation", INPUT=focos,
                  JOIN=f"{G}|layername=ucs", PREDICATE=[5], JOIN_FIELDS=["nome_uc"],
                  METHOD=0, DISCARD_NONMATCHING=True)

# 5. Contagem por UC e satélite
resumo = rodar("qgis:statisticsbycategories", INPUT=focos_ucs,
               CATEGORIES_FIELD_NAME=["nome_uc", "satelite"])
for f in resumo.getFeatures():
    print(f["nome_uc"], f["satelite"], f["count"])
QgsProject.instance().addMapLayer(focos_ucs)

-- 1. Tabela para os focos e carga dos três arquivos (o \copy roda no seu computador)
DROP TABLE IF EXISTS artigos.focos;
CREATE TABLE artigos.focos (
    id text, lat numeric, lon numeric, data_hora_gmt timestamp,
    satelite text, municipio text, estado text, pais text,
    municipio_id bigint, estado_id int, pais_id int,
    numero_dias_sem_chuva numeric, precipitacao numeric, risco_fogo numeric,
    bioma text, frp numeric
);
\copy artigos.focos FROM PROGRAM 'curl -s https://dataserver-coids.inpe.br/queimadas/queimadas/focos/csv/diario/Brasil/focos_diario_br_$(date -u +%Y%m%d).csv' CSV HEADER
\copy artigos.focos FROM PROGRAM 'curl -s https://dataserver-coids.inpe.br/queimadas/queimadas/focos/csv/diario/Brasil/focos_diario_br_$(date -u -d yesterday +%Y%m%d).csv' CSV HEADER
\copy artigos.focos FROM PROGRAM 'curl -s https://dataserver-coids.inpe.br/queimadas/queimadas/focos/csv/diario/Brasil/focos_diario_br_$(date -u -d "2 days ago" +%Y%m%d).csv' CSV HEADER

-- 2. Pontos
ALTER TABLE artigos.focos ADD COLUMN geom geometry(Point, 4674);
UPDATE artigos.focos SET geom = ST_SetSRID(ST_MakePoint(lon, lat), 4674);
CREATE INDEX ON artigos.focos USING gist (geom);

-- 3 a 5. Focos em UCs nas últimas 24 e 48 horas (hora em UTC)
SELECT u.nome_uc,
       count(*) FILTER (WHERE f.data_hora_gmt >= (now() AT TIME ZONE 'UTC') - interval '24 hours') AS focos_24h,
       count(*) AS focos_48h,
       count(*) FILTER (WHERE f.satelite = 'AQUA_M-T') AS focos_48h_referencia
FROM artigos.focos f
JOIN artigos.ucs u ON ST_Within(f.geom, u.geom)
WHERE f.data_hora_gmt >= (now() AT TIME ZONE 'UTC') - interval '48 hours'
GROUP BY u.nome_uc
ORDER BY focos_48h DESC;

from datetime import datetime, timedelta, timezone
import pandas as pd
import geopandas as gpd

url = ("https://dataserver-coids.inpe.br/queimadas/queimadas/focos/csv/diario/"
       "Brasil/focos_diario_br_{}.csv")

# 1. Baixar hoje, ontem e anteontem
agora = datetime.now(timezone.utc)
dias = [(agora - timedelta(days=i)).strftime("%Y%m%d") for i in range(3)]
focos = pd.concat([pd.read_csv(url.format(d)) for d in dias], ignore_index=True)
focos["data_hora_gmt"] = pd.to_datetime(focos["data_hora_gmt"], utc=True)

# 2. Pontos e 3. últimas 48 horas
focos = gpd.GeoDataFrame(focos, geometry=gpd.points_from_xy(focos.lon, focos.lat), crs=4674)
focos = focos[focos["data_hora_gmt"] >= agora - timedelta(hours=48)]
focos["janela"] = (focos["data_hora_gmt"] >= agora - timedelta(hours=24)).map(
    {True: "últimas 24 h", False: "24 a 48 h"})

# 4. Em qual UC (ou entorno) caiu cada foco
G = "dados/artigos.gpkg"
zonas = pd.concat([
    gpd.read_file(G, layer="ucs")[["nome_uc", "geometry"]].assign(local="interior"),
    gpd.read_file(G, layer="ucs_entorno")[["nome_uc", "geometry"]].assign(local="entorno"),
])
focos_ucs = gpd.sjoin(focos, zonas, predicate="within")

# 5. Contagem
print(pd.crosstab([focos_ucs["nome_uc"], focos_ucs["local"]], focos_ucs["janela"],
                  margins=True, margins_name="total"))
print(focos_ucs[focos_ucs["satelite"] == "AQUA_M-T"].groupby("nome_uc").size())
focos_ucs.to_file("dados/focos_ucs_48h.gpkg")

import processing
G = "C:/dados/artigos.gpkg"

campos = [
    ("ano", 1, 'year("view_date")'),
    ("mes", 1, 'month("view_date")'),
    ("mes_nome", 2, "array_get(array('Janeiro','Fevereiro','Março','Abril','Maio','Junho',"
                    "'Julho','Agosto','Setembro','Outubro','Novembro','Dezembro'), "
                    'month("view_date") - 1)'),
    ("ano_prodes", 1, 'year("view_date") + if(month("view_date") >= 8, 1, 0)'),
    ("mes_prodes", 1, '(month("view_date") + 4) % 12 + 1'),
]
camada = f"{G}|layername=deter"
for nome, tipo, formula in campos:          # tipo: 1 = inteiro, 2 = texto
    camada = processing.run("native:fieldcalculator", {
        "INPUT": camada, "FIELD_NAME": nome, "FIELD_TYPE": tipo, "FIELD_LENGTH": 12,
        "FORMULA": formula, "OUTPUT": "memory:"})["OUTPUT"]

resumo = processing.run("qgis:statisticsbycategories", {
    "INPUT": camada, "CATEGORIES_FIELD_NAME": ["ano_prodes"], "OUTPUT": "memory:"})["OUTPUT"]
for f in resumo.getFeatures():
    print(f["ano_prodes"], f["count"])

SELECT view_date,
       extract(year FROM view_date)::int                                   AS ano,
       extract(month FROM view_date)::int                                  AS mes,
       (ARRAY['Janeiro','Fevereiro','Março','Abril','Maio','Junho','Julho',
              'Agosto','Setembro','Outubro','Novembro','Dezembro'])
           [extract(month FROM view_date)::int]                            AS mes_nome,
       extract(year FROM view_date + interval '5 months')::int             AS ano_prodes,
       (extract(month FROM view_date)::int + 4) % 12 + 1                   AS mes_prodes
FROM artigos.deter
LIMIT 5;

-- Conferência: alertas por ano PRODES
SELECT extract(year FROM view_date + interval '5 months')::int AS ano_prodes, count(*)
FROM artigos.deter
GROUP BY 1
ORDER BY 1;

import geopandas as gpd

deter = gpd.read_file("dados/artigos.gpkg", layer="deter")
data = deter["view_date"].astype("datetime64[ns]")

MESES = ["Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho",
         "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"]

deter["ano"] = data.dt.year
deter["mes"] = data.dt.month
deter["mes_nome"] = deter["mes"].map(lambda m: MESES[m - 1])
deter["ano_prodes"] = deter["ano"] + (deter["mes"] >= 8).astype(int)
deter["mes_prodes"] = (deter["mes"] + 4) % 12 + 1

print(deter[["view_date", "ano", "mes", "mes_nome", "ano_prodes", "mes_prodes"]].head())
print(deter.groupby("ano_prodes").size())

consulta = """
WITH alertas AS (
    SELECT nome_uc,
           CAST(strftime('%Y', view_date) AS INTEGER)
             + (CAST(strftime('%m', view_date) AS INTEGER) >= 8)          AS ano_prodes,
           (CAST(strftime('%m', view_date) AS INTEGER) + 4) % 12 + 1      AS mes_prodes,
           area_ha
    FROM deter
    WHERE classname IN ('DESMATAMENTO_CR', 'DESMATAMENTO_VEG', 'MINERACAO')
      AND local = 'interior' AND area_ha >= 6.25
),
meses(mes_prodes) AS (SELECT 1 UNION ALL SELECT mes_prodes + 1 FROM meses WHERE mes_prodes < 12),
grade AS (
    SELECT u.nome_uc, a.ano_prodes, m.mes_prodes
    FROM (SELECT DISTINCT nome_uc FROM alertas) u,
         (SELECT DISTINCT ano_prodes FROM alertas) a, meses m
),
mensal AS (
    SELECT g.nome_uc, g.ano_prodes, g.mes_prodes, coalesce(sum(a.area_ha), 0) AS area_ha
    FROM grade g
    LEFT JOIN alertas a USING (nome_uc, ano_prodes, mes_prodes)
    GROUP BY g.nome_uc, g.ano_prodes, g.mes_prodes
),
ultimo AS (
    SELECT CAST(strftime('%Y', max(view_date)) AS INTEGER)
             + (CAST(strftime('%m', max(view_date)) AS INTEGER) >= 8)      AS ano,
           (CAST(strftime('%m', max(view_date)) AS INTEGER) + 4) % 12 + 1 AS mes
    FROM deter
)
SELECT m.*,
       sum(m.area_ha) OVER (PARTITION BY m.nome_uc, m.ano_prodes
                            ORDER BY m.mes_prodes) AS acumulado_ha,
       NOT (m.ano_prodes = u.ano AND m.mes_prodes > u.mes) AS valido
FROM mensal m, ultimo u
ORDER BY m.nome_uc, m.ano_prodes, m.mes_prodes
"""
deter = QgsVectorLayer("C:/dados/deter_interior_entorno.gpkg", "deter", "ogr")
QgsProject.instance().addMapLayer(deter)
tabela = QgsVectorLayer(f"?query={consulta}", "deter_mensal_acumulado", "virtual")
QgsProject.instance().addMapLayer(tabela)
print(tabela.featureCount(), "linhas")

CREATE OR REPLACE VIEW artigos.deter_mensal_acumulado AS
WITH alertas AS (
    SELECT nome_uc,
           extract(year FROM view_date + interval '5 months')::int AS ano_prodes,
           (extract(month FROM view_date)::int + 4) % 12 + 1      AS mes_prodes,
           area_ha
    FROM artigos.deter_interior_entorno
    WHERE classname IN ('DESMATAMENTO_CR', 'DESMATAMENTO_VEG', 'MINERACAO')
      AND local = 'interior' AND area_ha >= 6.25
),
grade AS (
    SELECT u.nome_uc, a.ano_prodes, m.mes_prodes
    FROM (SELECT DISTINCT nome_uc FROM alertas) u
    CROSS JOIN (SELECT DISTINCT ano_prodes FROM alertas) a
    CROSS JOIN generate_series(1, 12) AS m(mes_prodes)
),
mensal AS (
    SELECT g.nome_uc, g.ano_prodes, g.mes_prodes, coalesce(sum(a.area_ha), 0) AS area_ha
    FROM grade g
    LEFT JOIN alertas a USING (nome_uc, ano_prodes, mes_prodes)
    GROUP BY g.nome_uc, g.ano_prodes, g.mes_prodes
),
ultimo AS (
    SELECT extract(year FROM max(view_date) + interval '5 months')::int AS ano,
           (extract(month FROM max(view_date))::int + 4) % 12 + 1      AS mes
    FROM artigos.deter_interior_entorno
)
SELECT m.nome_uc, m.ano_prodes, m.mes_prodes, round(m.area_ha, 2) AS area_ha,
       round(sum(m.area_ha) OVER (PARTITION BY m.nome_uc, m.ano_prodes
                                  ORDER BY m.mes_prodes), 2) AS acumulado_ha,
       NOT (m.ano_prodes = u.ano AND m.mes_prodes > u.mes) AS valido
FROM mensal m, ultimo u;

SELECT * FROM artigos.deter_mensal_acumulado
WHERE nome_uc = 'FLORESTA NACIONAL DO JAMANXIM' AND ano_prodes = 2027
ORDER BY mes_prodes;

import geopandas as gpd
import pandas as pd

todos = gpd.read_file("dados/deter_interior_entorno.gpkg")
d = todos[todos["classname"].isin(["DESMATAMENTO_CR", "DESMATAMENTO_VEG", "MINERACAO"])
          & (todos["local"] == "interior") & (todos["area_ha"] >= 6.25)].copy()

# 2. Ano e mês PRODES
data = pd.to_datetime(d["view_date"])
d["ano_prodes"] = data.dt.year + (data.dt.month >= 8)
d["mes_prodes"] = (data.dt.month + 4) % 12 + 1

# 3 e 4. Grade completa e soma por mês (vazios = 0)
soma = d.groupby(["nome_uc", "ano_prodes", "mes_prodes"])["area_ha"].sum()
grade = pd.MultiIndex.from_product(
    [sorted(d["nome_uc"].unique()), sorted(d["ano_prodes"].unique()), range(1, 13)],
    names=soma.index.names)
tabela = soma.reindex(grade, fill_value=0).reset_index()

# 5. Acumulado no ano PRODES
tabela["acumulado_ha"] = tabela.groupby(["nome_uc", "ano_prodes"])["area_ha"].cumsum()

# 6. Meses depois do último dado
ultimo = pd.to_datetime(todos["view_date"]).max()
ano_u, mes_u = ultimo.year + (ultimo.month >= 8), (ultimo.month + 4) % 12 + 1
tabela["valido"] = ~((tabela["ano_prodes"] == ano_u) & (tabela["mes_prodes"] > mes_u))

tabela.round(2).to_csv("dados/deter_mensal_acumulado.csv", index=False)
print(tabela.query("nome_uc == 'FLORESTA NACIONAL DO JAMANXIM' and ano_prodes == 2027").round(2))

import processing
G = "C:/dados/artigos.gpkg"

# 1. Junção por campo
alertas = processing.run("native:joinattributestable", {
    "INPUT": "C:/dados/deter_interior_entorno.gpkg",
    "FIELD": "cnuc", "INPUT_2": f"{G}|layername=ucs", "FIELD_2": "cnuc",
    "FIELDS_TO_COPY": ["categoria", "grupo", "esfera"], "METHOD": 1,   # 1 = só a primeira
    "OUTPUT": "memory:"})["OUTPUT"]

# 2. Uma linha por UC, com a lista de municípios e o total de área
municipios = processing.run("native:aggregate", {
    "INPUT": alertas, "GROUP_BY": "nome_uc",
    "AGGREGATES": [
        {"aggregate": "first_value", "input": '"nome_uc"', "name": "nome_uc",
         "type": 10, "length": 120, "precision": 0, "delimiter": ""},
        {"aggregate": "first_value", "input": '"categoria"', "name": "categoria",
         "type": 10, "length": 80, "precision": 0, "delimiter": ""},
        {"aggregate": "concatenate_unique", "input": '"municipality"', "name": "municipios",
         "type": 10, "length": 500, "precision": 0, "delimiter": ", "},
        {"aggregate": "sum", "input": '"area_ha"', "name": "area_ha",
         "type": 6, "length": 0, "precision": 2, "delimiter": ""},
    ],
    "OUTPUT": "memory:"})["OUTPUT"]

for f in municipios.getFeatures():
    print(f["nome_uc"], "|", f["categoria"], "|", f["municipios"], "|", round(f["area_ha"]))

-- 1. Junção por campo
SELECT a.gid, a.nome_uc, a.local, a.area_ha, u.categoria, u.grupo, u.esfera
FROM artigos.deter_interior_entorno a
JOIN artigos.ucs u USING (cnuc)
LIMIT 5;

-- 2. Uma linha por UC, com a lista de municípios
SELECT a.nome_uc, u.categoria,
       string_agg(DISTINCT a.municipality, ', ' ORDER BY a.municipality) AS municipios,
       round(sum(a.area_ha)) AS area_ha
FROM artigos.deter_interior_entorno a
JOIN artigos.ucs u USING (cnuc)
GROUP BY a.nome_uc, u.categoria
ORDER BY area_ha DESC;

import geopandas as gpd

alertas = gpd.read_file("dados/deter_interior_entorno.gpkg")
ucs = gpd.read_file("dados/artigos.gpkg", layer="ucs")

# 1. Junção por campo (validate confere que cada cnuc aparece uma vez só nas UCs)
alertas = alertas.merge(ucs[["cnuc", "categoria", "grupo", "esfera"]],
                        on="cnuc", how="left", validate="many_to_one")

# 2. Uma linha por UC, com a lista de municípios
lista = lambda s: ", ".join(sorted(s.dropna().unique()))
municipios = (alertas.groupby("nome_uc")
              .agg(categoria=("categoria", "first"), municipios=("municipality", lista),
                   area_ha=("area_ha", "sum"))
              .round(0).sort_values("area_ha", ascending=False))
print(municipios.to_string())

import processing
G = "C:/dados/artigos.gpkg"
AREA = "area(transform($geometry, 'EPSG:4674', 'ESRI:102033')) / 10000"

def rodar(alg, **p):
    p.setdefault("OUTPUT", "memory:")
    return processing.run(alg, p)["OUTPUT"]

ucs = rodar("native:extractbyexpression", INPUT=f"{G}|layername=ucs",
            EXPRESSION="regiao = 'Amazonia'")

# 1. Seleção por localização (predicado 0 = intersecta)
car = rodar("native:extractbylocation", INPUT=f"{G}|layername=car", INTERSECT=ucs,
            PREDICATE=[0])
print("imóveis que tocam as UCs:", car.featureCount())

# 2 e 3. Área do imóvel, interseção, área sobreposta e porcentagem
car = rodar("native:fieldcalculator", INPUT=car, FIELD_NAME="area_imovel_ha",
            FIELD_TYPE=0, FIELD_PRECISION=4, FORMULA=AREA)
car_ucs = rodar("native:intersection", INPUT=car, OVERLAY=ucs,
                OVERLAY_FIELDS=["cnuc", "nome_uc", "grupo"])
car_ucs = rodar("native:fieldcalculator", INPUT=car_ucs, FIELD_NAME="sobreposicao_ha",
                FIELD_TYPE=0, FIELD_PRECISION=4, FORMULA=AREA)
car_ucs = rodar("native:fieldcalculator", INPUT=car_ucs, FIELD_NAME="pct_imovel",
                FIELD_TYPE=0, FIELD_PRECISION=2,
                FORMULA='100 * "sobreposicao_ha" / "area_imovel_ha"')

# 4. Resumo por UC e situação (pelo menos 1% dentro)
dentro = rodar("native:extractbyexpression", INPUT=car_ucs, EXPRESSION='"pct_imovel" >= 1')
resumo = rodar("qgis:statisticsbycategories", INPUT=dentro, VALUES_FIELD_NAME="sobreposicao_ha",
               CATEGORIES_FIELD_NAME=["nome_uc", "status_imovel"])
for f in resumo.getFeatures():
    print(f["nome_uc"], f["status_imovel"], f["count"], round(f["sum"]))

# Área da UC coberta por CAR, sem contar sobreposições entre imóveis
coberta = rodar("native:dissolve", INPUT=dentro, FIELD=["nome_uc"])
coberta = rodar("native:fieldcalculator", INPUT=coberta, FIELD_NAME="coberta_ha",
                FIELD_TYPE=0, FIELD_PRECISION=1, FORMULA=AREA)
for f in coberta.getFeatures():
    print(f["nome_uc"], "coberta por CAR:", round(f["coberta_ha"]), "ha")

-- 1 a 3. Imóveis que tocam as UCs, área sobreposta e porcentagem do imóvel
DROP TABLE IF EXISTS artigos.car_ucs;
CREATE TABLE artigos.car_ucs AS
SELECT c.cod_imovel, c.status_imovel, c.tipo_imovel, u.cnuc, u.nome_uc, u.grupo,
       ST_Area(c.geom::geography) / 10000                         AS area_imovel_ha,
       ST_Area(ST_Intersection(c.geom, u.geom)::geography) / 10000 AS sobreposicao_ha,
       ST_Intersection(c.geom, u.geom)                            AS geom
FROM artigos.car c
JOIN artigos.ucs u ON u.regiao = 'Amazonia' AND ST_Intersects(c.geom, u.geom);

ALTER TABLE artigos.car_ucs ADD COLUMN pct_imovel numeric;
UPDATE artigos.car_ucs SET pct_imovel = 100 * sobreposicao_ha / area_imovel_ha;

-- 4. Resumo por UC (só quem tem pelo menos 1% dentro)
SELECT nome_uc, grupo,
       count(*)                                         AS imoveis,
       count(*) FILTER (WHERE status_imovel = 'AT')     AS ativos,
       count(*) FILTER (WHERE status_imovel = 'PE')     AS pendentes,
       count(*) FILTER (WHERE status_imovel = 'SU')     AS suspensos,
       count(*) FILTER (WHERE status_imovel = 'CA')     AS cancelados,
       round(sum(sobreposicao_ha))                      AS soma_sobreposicao_ha,
       round((ST_Area(ST_Union(geom)::geography) / 10000)::numeric) AS coberta_ha
FROM artigos.car_ucs
WHERE pct_imovel >= 1
GROUP BY nome_uc, grupo
ORDER BY coberta_ha DESC;

import geopandas as gpd

G = "dados/artigos.gpkg"
ucs = gpd.read_file(G, layer="ucs").query("regiao == 'Amazonia'")
car = gpd.read_file(G, layer="car")
ALBERS = "ESRI:102033"                       # projeção de área igual

# 1. Seleção por localização
toca = car[car.intersects(ucs.union_all())].copy()
print("imóveis que tocam as UCs:", len(toca))

# 2 e 3. Interseção, área sobreposta e porcentagem do imóvel
toca["area_imovel_ha"] = toca.to_crs(ALBERS).area / 10_000
car_ucs = gpd.overlay(toca, ucs[["cnuc", "nome_uc", "grupo", "geometry"]],
                      how="intersection", keep_geom_type=True)
car_ucs["sobreposicao_ha"] = car_ucs.to_crs(ALBERS).area / 10_000
car_ucs["pct_imovel"] = 100 * car_ucs["sobreposicao_ha"] / car_ucs["area_imovel_ha"]

# 4. Resumo por UC (pelo menos 1% dentro)
dentro = car_ucs[car_ucs["pct_imovel"] >= 1]
resumo = dentro.pivot_table(index="nome_uc", columns="status_imovel", values="cod_imovel",
                            aggfunc="count", fill_value=0)
resumo["soma_sobreposicao_ha"] = dentro.groupby("nome_uc")["sobreposicao_ha"].sum().round()
resumo["coberta_ha"] = (dentro.dissolve("nome_uc").to_crs(ALBERS).area / 10_000).round()
print(resumo.sort_values("coberta_ha", ascending=False))

import processing
G = "C:/dados/artigos.gpkg"
SAIDA = "C:/dados/"

def rodar(alg, **p):
    p.setdefault("OUTPUT", "memory:")
    return processing.run(alg, p)["OUTPUT"]

# 1. Polígonos de 2025, área em hectares e ponto dentro de cada um (em metros)
prodes = rodar("native:extractbyexpression", INPUT=f"{G}|layername=prodes_amz",
               EXPRESSION="year = 2025 AND upper(main_class) = 'DESMATAMENTO'")
prodes = rodar("native:fixgeometries", INPUT=prodes)
prodes = rodar("native:removenullgeometries", INPUT=prodes, REMOVE_EMPTY=True)  # lascas
prodes = rodar("native:fieldcalculator", INPUT=prodes, FIELD_NAME="area_ha", FIELD_TYPE=0,
               FIELD_PRECISION=4,
               FORMULA="area(transform($geometry, 'EPSG:4674', 'ESRI:102033')) / 10000")
pontos = rodar("native:pointonsurface", INPUT=prodes)
pontos = rodar("native:reprojectlayer", INPUT=pontos, TARGET_CRS="EPSG:5880")

# 2. Mapa de calor (núcleo quártico), com e sem peso
kernel = dict(INPUT=pontos, RADIUS=10000, PIXEL_SIZE=1000, KERNEL=0, OUTPUT_VALUE=0)
kd_area = rodar("native:heatmapkerneldensityestimation", **kernel, WEIGHT_FIELD="area_ha",
                OUTPUT=SAIDA + "kd_area.tif")
kd_qtde = rodar("native:heatmapkerneldensityestimation", **kernel,
                OUTPUT=SAIDA + "kd_qtde.tif")

# 3. Normalizar (0 a 1) e tirar a média
norm_area = rodar("native:rescaleraster", INPUT=kd_area, BAND=1, MINIMUM=0, MAXIMUM=1,
                  OUTPUT=SAIDA + "kd_area_norm.tif")
norm_qtde = rodar("native:rescaleraster", INPUT=kd_qtde, BAND=1, MINIMUM=0, MAXIMUM=1,
                  OUTPUT=SAIDA + "kd_qtde_norm.tif")
indice = rodar("gdal:rastercalculator", INPUT_A=norm_area, BAND_A=1, INPUT_B=norm_qtde,
               BAND_B=1, FORMULA="(A + B) / 2", RTYPE=5, OUTPUT=SAIDA + "kernel_media.tif")

# O mapa de calor só cobre a área dos pontos mais o raio, e grava "sem dado" onde a
# densidade é zero: estender até o recorte e trocar "sem dado" por zero
indice = rodar("gdal:warpreproject", INPUT=indice, TARGET_CRS="EPSG:5880",
               TARGET_RESOLUTION=1000, TARGET_EXTENT="-56.5,-54.5,-8.5,-5.5",
               TARGET_EXTENT_CRS="EPSG:4674", OUTPUT=SAIDA + "kernel_recorte.tif")
indice = rodar("native:fillnodata", INPUT=indice, BAND=1, FILL_VALUE=0,
               OUTPUT=SAIDA + "kernel_indice.tif")

# 4. Média e máximo do índice em cada UC, só na parte dentro do recorte
ucs = rodar("native:extractbyexpression", INPUT=f"{G}|layername=ucs",
            EXPRESSION="regiao = 'Amazonia'")
ucs = rodar("native:extractbyextent", INPUT=ucs, CLIP=True,
            EXTENT="-56.5,-54.5,-8.5,-5.5 [EPSG:4674]")
ucs = rodar("native:fixgeometries", INPUT=ucs)
ucs = rodar("native:reprojectlayer", INPUT=ucs, TARGET_CRS="EPSG:5880")
por_uc = rodar("native:zonalstatisticsfb", INPUT=ucs, INPUT_RASTER=indice, RASTER_BAND=1,
               STATISTICS=[2, 6], COLUMN_PREFIX="idx_")          # 2 = média, 6 = máximo
for f in por_uc.getFeatures():
    print(f["nome_uc"], round(f["idx_mean"], 3), round(f["idx_max"], 3))
QgsProject.instance().addMapLayer(QgsRasterLayer(indice, "Índice Kernel"))

-- 1. Um ponto dentro de cada polígono de 2025 (em metros) e a área em hectares
DROP TABLE IF EXISTS artigos.kernel_pontos;
CREATE TABLE artigos.kernel_pontos AS
SELECT ST_Transform(ST_PointOnSurface(g), 5880) AS geom,
       ST_Area(g::geography) / 10000 AS area_ha
FROM (SELECT ST_CollectionExtract(ST_MakeValid(geom), 3) AS g
      FROM artigos.prodes_amz
      WHERE year = 2025 AND upper(main_class) = 'DESMATAMENTO') p
WHERE NOT ST_IsEmpty(g);
CREATE INDEX ON artigos.kernel_pontos USING gist (geom);

-- 2. Grade de 1 km sobre a área dos pontos (mais 10 km de margem) e as duas densidades
DROP TABLE IF EXISTS artigos.kernel_grade;
CREATE TABLE artigos.kernel_grade AS
WITH grade AS (
    SELECT ST_Centroid(c.geom) AS geom
    FROM ST_SquareGrid(1000, (SELECT ST_SetSRID(ST_Expand(ST_Extent(geom), 10000)::geometry, 5880)
                              FROM artigos.kernel_pontos)) AS c
),
quartico AS (                       -- peso: (1 - (d/r)²)², de 1 no centro a 0 em 10 km
    SELECT g.geom, p.area_ha,
           power(1 - power(ST_Distance(g.geom, p.geom) / 10000, 2), 2) AS w
    FROM grade g
    JOIN artigos.kernel_pontos p ON ST_DWithin(g.geom, p.geom, 10000)
)
SELECT geom, sum(w * area_ha) AS kd_area, sum(w) AS kd_qtde
FROM quartico
GROUP BY geom;

-- 3. Normalizar e tirar a média (células sem desmatamento por perto ficam com 0)
ALTER TABLE artigos.kernel_grade ADD COLUMN indice numeric;
WITH lim AS (SELECT max(kd_area) AS ma, max(kd_qtde) AS mq FROM artigos.kernel_grade)
UPDATE artigos.kernel_grade SET indice = ((kd_area / ma) + (kd_qtde / mq)) / 2 FROM lim;
CREATE INDEX ON artigos.kernel_grade USING gist (geom);

-- 4. Média e máximo do índice em cada UC, só dentro do recorte (células com zero contam)
WITH ucs AS (
    SELECT nome_uc,
           ST_Transform(ST_Intersection(geom, ST_MakeEnvelope(-56.5, -8.5, -54.5, -5.5, 4674)),
                        5880) AS geom
    FROM artigos.ucs
    WHERE regiao = 'Amazonia'
)
SELECT u.nome_uc,
       round(avg(coalesce(k.indice, 0)), 3) AS idx_media,
       round(max(coalesce(k.indice, 0)), 3) AS idx_max
FROM ucs u
CROSS JOIN LATERAL ST_SquareGrid(1000, u.geom) AS c
LEFT JOIN artigos.kernel_grade k ON k.geom = ST_Centroid(c.geom)
WHERE ST_Intersects(ST_Centroid(c.geom), u.geom)
GROUP BY u.nome_uc
ORDER BY idx_media DESC;

import numpy as np
import geopandas as gpd
from shapely.geometry import box
from rasterio.transform import from_origin
from rasterstats import zonal_stats

G = "dados/artigos.gpkg"
RAIO, CEL = 10_000, 1_000                         # metros
recorte = gpd.GeoSeries([box(-56.5, -8.5, -54.5, -5.5)], crs=4674)

# 1. Polígonos de 2025, área em hectares e ponto dentro de cada um (em metros)
prodes = gpd.read_file(G, layer="prodes_amz")
prodes = prodes[(prodes["year"] == 2025) & (prodes["main_class"].str.upper() == "DESMATAMENTO")]
prodes["geometry"] = prodes.make_valid(method="structure", keep_collapsed=False)
prodes = prodes[~prodes.is_empty]
peso = prodes.to_crs("ESRI:102033").area.values / 10_000
pontos = prodes.representative_point().to_crs(5880)
x, y = pontos.x.values, pontos.y.values

# 2. Grade de 1 km sobre o recorte e núcleo quártico, ponto a ponto
xmin, ymin, xmax, ymax = recorte.to_crs(5880).total_bounds
x0, y1 = xmin, ymax
ncol = int((xmax - x0) // CEL) + 1
nlin = int((y1 - ymin) // CEL) + 1
cx = x0 + (np.arange(ncol) + 0.5) * CEL           # centro das colunas
cy = y1 - (np.arange(nlin) + 0.5) * CEL           # centro das linhas
kd_area = np.zeros((nlin, ncol))
kd_qtde = np.zeros((nlin, ncol))
for xi, yi, wi in zip(x, y, peso):
    c = slice(max(0, int((xi - RAIO - x0) // CEL)), int((xi + RAIO - x0) // CEL) + 1)
    l = slice(max(0, int((y1 - yi - RAIO) // CEL)), int((y1 - yi + RAIO) // CEL) + 1)
    d2 = (cx[c][None, :] - xi) ** 2 + (cy[l][:, None] - yi) ** 2
    k = np.where(d2 < RAIO ** 2, (1 - d2 / RAIO ** 2) ** 2, 0)
    kd_area[l, c] += wi * k
    kd_qtde[l, c] += k

# 3. Normalizar (o mínimo é zero) e tirar a média
indice = (kd_area / kd_area.max() + kd_qtde / kd_qtde.max()) / 2

# 4. Média e máximo do índice em cada UC, só dentro do recorte
ucs = gpd.read_file(G, layer="ucs").query("regiao == 'Amazonia'")
ucs = gpd.clip(ucs, recorte).to_crs(5880)
stats = zonal_stats(ucs, indice, affine=from_origin(x0, y1, CEL, CEL),
                    stats=["mean", "max"], nodata=-1)
ucs["idx_media"] = [round(s["mean"], 3) for s in stats]
ucs["idx_max"] = [round(s["max"], 3) for s in stats]
print(ucs[["nome_uc", "idx_media", "idx_max"]].sort_values("idx_media", ascending=False))
np.save("dados/kernel_indice.npy", indice)

import arcpy

projeto = arcpy.mp.ArcGISProject(r"C:\dados\mapas.aprx")
layout = projeto.listLayouts("Mapa por UC")[0]
quadro = layout.listElements("MAPFRAME_ELEMENT")[0]
titulo = layout.listElements("TEXT_ELEMENT", "titulo")[0]
ucs = quadro.map.listLayers("UCs")[0]

for cnuc, nome in arcpy.da.SearchCursor(ucs, ["cnuc", "nome_uc"]):
    ucs.definitionQuery = f"cnuc = '{cnuc}'"
    quadro.camera.setExtent(quadro.getLayerExtent(ucs, False, True))
    quadro.camera.scale *= 1.1                     # 10% de margem
    titulo.text = nome
    layout.exportToPNG(rf"C:\dados\mapas\mapa_{cnuc}.png", resolution=150)
    print(f"Mapa de {nome} exportado")
ucs.definitionQuery = ""

layout.mapSeries.exportToPDF(r"C:\dados\mapas\mapas.pdf", "ALL", multiple_files="PDF_SINGLE_FILE")

import os
from qgis.core import (QgsProject, QgsVectorLayer, QgsPrintLayout, QgsLayoutItemMap,
                       QgsLayoutItemLabel, QgsLayoutItemLegend, QgsLayoutItemScaleBar,
                       QgsLayoutItemPicture, QgsLayoutPoint, QgsLayoutSize, QgsUnitTypes,
                       QgsLayoutExporter, QgsCategorizedSymbolRenderer, QgsRendererCategory,
                       QgsFillSymbol, QgsSingleSymbolRenderer, QgsCoordinateReferenceSystem,
                       QgsCoordinateTransform, QgsRuleBasedRenderer)
from qgis.PyQt.QtGui import QFont

G = "C:/dados/artigos.gpkg"
PASTA = "C:/dados/mapas/"
os.makedirs(PASTA, exist_ok=True)
projeto = QgsProject.instance()
MM = QgsUnitTypes.LayoutMillimeters

def poligono(**estilo):
    return QgsFillSymbol.createSimple(estilo)

# 1. Camadas e estilos: UCs (comandam o atlas), entorno e alertas desde agosto de 2026
ucs = QgsVectorLayer(f"{G}|layername=ucs", "Unidade de Conservação", "ogr")
ucs.setSubsetString("regiao = 'Amazonia'")
extensao_ucs = ucs.extent()
def regras(*lista):
    """Estilo por regras: (rótulo, expressão, símbolo). @atlas_feature é a UC da página."""
    raiz = QgsRuleBasedRenderer.Rule(None)
    for rotulo, expressao, simbolo in lista:
        raiz.appendChild(QgsRuleBasedRenderer.Rule(simbolo, filterExp=expressao, label=rotulo))
    return QgsRuleBasedRenderer(raiz)

ucs.setRenderer(regras(
    ("UC do mapa", "@atlas_featureid = $id",
     poligono(color="229,236,220", outline_color="0,0,0", outline_width="0.8")),
    ("Outras UCs", "@atlas_featureid <> $id",
     poligono(color="242,242,242", outline_color="150,150,150", outline_width="0.3"))))
entorno = QgsVectorLayer(f"{G}|layername=ucs_entorno", "Entorno", "ogr")
entorno.setRenderer(regras(
    ("Entorno de 3 km", "\"cnuc\" = attribute(@atlas_feature, 'cnuc')",
     poligono(color="240,228,66,140", outline_style="no"))))
alertas = QgsVectorLayer(f"{G}|layername=deter", "Alertas DETER", "ogr")
alertas.setSubsetString("view_date >= '2026-08-01'")
classes = [("DESMATAMENTO_CR", "213,94,0", "Desmatamento (corte raso)"),
           ("MINERACAO", "204,121,167", "Mineração"),
           ("DEGRADACAO", "230,159,0", "Degradação"),
           ("CICATRIZ_DE_QUEIMADA", "86,180,233", "Cicatriz de queimada")]
categorias = [QgsRendererCategory(valor, poligono(color=cor, outline_color=cor,
                                                  outline_width="0.15"), rotulo)
              for valor, cor, rotulo in classes]
categorias.append(QgsRendererCategory(None, poligono(color="120,120,120", outline_style="no"),
                                      "Outras classes"))
alertas.setRenderer(QgsCategorizedSymbolRenderer("classname", categorias))
projeto.addMapLayers([ucs, entorno, alertas])

# 2. Layout A4 deitado (cada item é adicionado e depois posicionado, em milímetros)
layout = QgsPrintLayout(projeto)
layout.initializeDefaults()

def colocar(item, x, y, largura=None, altura=None):
    layout.addLayoutItem(item)
    item.attemptMove(QgsLayoutPoint(x, y, MM))
    if largura:
        item.attemptResize(QgsLayoutSize(largura, altura, MM))
    return item

mapa = QgsLayoutItemMap(layout)
crs_mapa = QgsCoordinateReferenceSystem("EPSG:5880")       # em metros: escala correta
mapa.setCrs(crs_mapa)
mapa.setLayers([alertas, entorno, ucs])
mapa.setFrameEnabled(True)
colocar(mapa, 8, 22, 200, 180)
# Extensão inicial: sem ela, o atlas estica o quadro do mapa na primeira página
para_metros = QgsCoordinateTransform(ucs.crs(), crs_mapa, projeto)
mapa.zoomToExtent(para_metros.transformBoundingBox(extensao_ucs))

titulo = QgsLayoutItemLabel(layout)
titulo.setText('[% "nome_uc" %]')                            # muda a cada página
titulo.setFont(QFont("DejaVu Sans", 16, QFont.Weight.Bold))
colocar(titulo, 8, 6, 280, 12)

legenda = QgsLayoutItemLegend(layout)
legenda.setLinkedMap(mapa)
legenda.setTitle("Legenda")
colocar(legenda, 214, 22)

norte = QgsLayoutItemPicture(layout)
norte.setPicturePath(":/images/north_arrows/layout_default_north_arrow.svg")
colocar(norte, 270, 138, 15, 15)
norte.setLinkedMap(mapa)

escala = QgsLayoutItemScaleBar(layout)
escala.setLinkedMap(mapa)
escala.setStyle("Single Box")
escala.setUnits(QgsUnitTypes.DistanceKilometers)
escala.setUnitLabel("km")
escala.setNumberOfSegments(2)
escala.setNumberOfSegmentsLeft(0)
escala.setUnitsPerSegment(20)
colocar(escala, 214, 165)

fonte = QgsLayoutItemLabel(layout)
fonte.setText("Alertas DETER desde 01/08/2026.\nFontes: INPE/TerraBrasilis, MMA (CNUC).\n"
              "SIRGAS 2000 / Brazil Polyconic (EPSG:5880).")
colocar(fonte, 214, 182, 80, 20)

# 3. Atlas: uma página por UC, mapa centrado na UC com 10% de margem
atlas = layout.atlas()
atlas.setCoverageLayer(ucs)
atlas.setEnabled(True)
atlas.setFilenameExpression("'mapa_' || \"cnuc\"")
mapa.setAtlasDriven(True)
mapa.setAtlasScalingMode(QgsLayoutItemMap.Auto)
mapa.setAtlasMargin(0.10)

# 4. Uma imagem PNG por UC
config = QgsLayoutExporter.ImageExportSettings()
config.dpi = 150
config.generateWorldFile = False
config.exportMetadata = False
resultado, erro = QgsLayoutExporter.exportToImage(atlas, PASTA + "mapa.png", "png", config)
print("exportação:", "ok" if resultado == QgsLayoutExporter.Success else erro)
print(sorted(os.listdir(PASTA)))

CREATE OR REPLACE VIEW artigos.mapa_alertas_recentes AS
SELECT d.gid, d.classname, d.view_date, z.cnuc, z.nome_uc, z.local, z.geom
FROM artigos.deter_interior_entorno z
JOIN artigos.deter d USING (gid)
WHERE d.view_date >= current_date - 90;

import os
import geopandas as gpd
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib.patches import Patch

G = "dados/artigos.gpkg"
os.makedirs("dados/mapas_py", exist_ok=True)
ucs = gpd.read_file(G, layer="ucs").query("regiao == 'Amazonia'").to_crs(5880)
entorno = gpd.read_file(G, layer="ucs_entorno").to_crs(5880)
alertas = gpd.read_file(G, layer="deter").to_crs(5880)
alertas = alertas[alertas["view_date"].astype(str) >= "2026-08-01"]

CORES = {"DESMATAMENTO_CR": ("#D55E00", "Desmatamento (corte raso)"),
         "MINERACAO": ("#CC79A7", "Mineração"), "DEGRADACAO": ("#E69F00", "Degradação"),
         "CICATRIZ_DE_QUEIMADA": ("#56B4E9", "Cicatriz de queimada")}
alertas["cor"] = alertas["classname"].map(lambda c: CORES.get(c, ("#787878", ""))[0])

for _, uc in ucs.iterrows():
    fig, ax = plt.subplots(figsize=(11.7, 8.3))                    # A4 deitado
    xmin, ymin, xmax, ymax = uc.geometry.bounds
    m = 0.10 * max(xmax - xmin, ymax - ymin)                       # 10% de margem
    ax.set_xlim(xmin - m, xmax + m)
    ax.set_ylim(ymin - m, ymax + m)

    ucs.plot(ax=ax, color="#f2f2f2", edgecolor="#969696", linewidth=0.4)
    entorno[entorno["cnuc"] == uc["cnuc"]].plot(ax=ax, color="#F0E442", alpha=0.55)
    ucs[ucs["cnuc"] == uc["cnuc"]].plot(ax=ax, color="#e5ecdc", edgecolor="black", linewidth=1.2)
    alertas.plot(ax=ax, color=alertas["cor"], linewidth=0)

    # Escala de 20 km, norte, legenda, título e fonte
    x0, y0 = ax.get_xlim()[0] + m * 0.4, ax.get_ylim()[0] + m * 0.4
    ax.plot([x0, x0 + 20_000], [y0, y0], color="black", linewidth=3)
    ax.text(x0 + 10_000, y0 + m * 0.12, "20 km", ha="center", fontsize=9)
    ax.annotate("N", xy=(0.95, 0.95), xytext=(0.95, 0.86), xycoords="axes fraction",
                ha="center", fontsize=12, fontweight="bold",
                arrowprops=dict(facecolor="black", width=4, headwidth=12))
    itens = [Patch(facecolor="#e5ecdc", edgecolor="black", label="UC do mapa"),
             Patch(facecolor="#F0E442", alpha=0.55, label="Entorno de 3 km")]
    itens += [Patch(color=cor, label=rotulo) for cor, rotulo in CORES.values()]
    ax.legend(handles=itens, loc="upper left", fontsize=9, framealpha=0.9)
    ax.set_title(uc["nome_uc"], fontsize=15, fontweight="bold", loc="left")
    ax.set_axis_off()
    fig.text(0.01, 0.01, "Alertas DETER desde 01/08/2026. Fontes: INPE/TerraBrasilis, "
             "MMA (CNUC). SIRGAS 2000 / Brazil Polyconic (EPSG:5880).", fontsize=8)
    fig.savefig(f"dados/mapas_py/mapa_{uc['cnuc']}.png", dpi=150, bbox_inches="tight")
    plt.close(fig)
    print("Mapa de", uc["nome_uc"], "exportado")