// Mapa das calçadas: ruas coloridas pela avaliação das fotos, num gradiente
// que depende do zoom; avaliação das fotos à mão, exportação para o Roboflow
// e, no servidor local, coleta de ruas novas. Os dados vêm do Supabase (o
// site) ou do servidor local (scripts/interface/servidor.py): ver dados.js.
// As classes de avaliação (banco.CLASSES_AVALIACAO): cor e nome na tela.
const CORES = {
adequada: "#1a9641",
parcialmente_adequada: "#a88400",
inadequada: "#e66101",
sem_calcada: "#b2182b",
nao_identificavel: "#7b3294",
};
const NOMES = {
adequada: "Adequada",
parcialmente_adequada: "Parcialmente adequada",
inadequada: "Inadequada",
sem_calcada: "Sem calçada",
nao_identificavel: "Não identificável",
};
// Da melhor para a pior (a ordem dos botões e das teclas 1–5), e por fim a que não tem nota.
const CLASSES = ["adequada", "parcialmente_adequada", "inadequada", "sem_calcada", "nao_identificavel"];
// Nota de cada classe, de 0 (pior) a 1 (melhor). `nao_identificavel` não tem
// nota: não diz nada sobre a calçada.
const NOTAS = { adequada: 1, parcialmente_adequada: 0.7, inadequada: 0.4, sem_calcada: 0 };
// O nome de cada classe no projeto do Roboflow (sem acento, como o
// scripts/transformacao/extract_features.py procura).
const NOMES_ROBOFLOW = {
adequada: "Adequada", parcialmente_adequada: "Parcialmente Adequado", inadequada: "Inadequada",
sem_calcada: "Sem calcada", nao_identificavel: "Nao identificavel",
};
// Escala de cores da nota (0 = sem calçada, 0.4 = inadequada, 0.7 =
// parcialmente adequada, 1 = adequada).
// Fica toda verde a partir de 0.85: uma rua em sua maioria adequada é verde.
const ESCALA = [[0, "#b2182b"], [0.4, "#e66101"], [0.65, "#e8b81e"], [0.85, "#1a9641"], [1, "#1a9641"]];
const NIVEIS = 40; // tons distintos da escala: trechos vizinhos com o mesmo tom viram uma linha só
// Raio da média (ver notaEm), em pixels de tela: o mesmo em qualquer zoom,
// então de longe ele cobre a rua inteira e de perto só as fotos vizinhas.
const RAIO_PX = 30;
const RAIO_MIN = 15; // m: abaixo disso, o detalhe seria menor que uma zona de coleta
const $ = (id) => document.getElementById(id);
const el = (tag, props = {}, ...filhos) => {
const e = document.createElement(tag);
for (const [chave, valor] of Object.entries(props)) {
if (chave.includes("-")) e.setAttribute(chave, valor); // aria-*, data-*
else e[chave] = valor;
}
e.append(...filhos);
return e;
};
// A API da coleta, no servidor local (os dados do mapa vêm de FONTE, dados.js).
async function api(rota, corpo) {
const resp = await fetch(rota, corpo === undefined ? {} : {
method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(corpo),
});
const dados = await resp.json();
if (!resp.ok) throw Object.assign(new Error(dados.erro || resp.statusText), { dados, status: resp.status });
return dados;
}
function esc(texto) {
return String(texto ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" }[c]));
}
function corDaNota(nota) {
const hex = (h) => [1, 3, 5].map((i) => parseInt(h.slice(i, i + 2), 16));
for (let i = 1; i < ESCALA.length; i++) {
const [n1, c1] = ESCALA[i];
if (nota <= n1) {
const [n0, c0] = ESCALA[i - 1];
const t = (nota - n0) / (n1 - n0 || 1);
const [a, b] = [hex(c0), hex(c1)];
return `rgb(${a.map((v, j) => Math.round(v + t * (b[j] - v))).join(",")})`;
}
}
return ESCALA[ESCALA.length - 1][1];
}
// --------------------------------------------------------------------------
// Mapa
// --------------------------------------------------------------------------
// Canvas com tolerância: as linhas finas (1 px de longe) ainda pegam o mouse e o toque.
const mapa = L.map("mapa", { renderer: L.canvas({ tolerance: 8 }), zoomControl: false }).setView([-25.4284, -49.2733], 13);
const icone = (nome) => ``;
function lerPreferencia(chave, padrao) {
try { return localStorage.getItem(chave) || padrao; } catch { return padrao; }
}
function gravarPreferencia(chave, valor) {
try { localStorage.setItem(chave, valor); } catch {}
}
// Botão de recolher o painel lateral, acima do zoom; a escolha fica no navegador.
const BotaoPainel = L.Control.extend({
onAdd() {
const barra = L.DomUtil.create("div", "leaflet-bar");
const botao = L.DomUtil.create("a", "alternar-painel", barra);
botao.href = "#";
botao.setAttribute("role", "button");
botao.setAttribute("aria-controls", "painel");
const atualizar = () => {
const recolhido = document.body.classList.contains("painel-recolhido");
botao.innerHTML = icone(recolhido ? "panel-open" : "panel-close");
botao.title = recolhido ? "Mostrar o painel" : "Recolher o painel";
botao.setAttribute("aria-label", botao.title);
botao.setAttribute("aria-expanded", String(!recolhido));
};
L.DomEvent.disableClickPropagation(barra);
L.DomEvent.on(botao, "click", (ev) => {
L.DomEvent.preventDefault(ev);
const recolhido = document.body.classList.toggle("painel-recolhido");
gravarPreferencia("painelRecolhido", recolhido ? "1" : "");
atualizar();
// Depois da animação da coluna (180 ms), o mapa mede de novo a largura final.
setTimeout(() => mapa.invalidateSize(), duracao(260) + 20);
});
atualizar();
return barra;
},
});
if (lerPreferencia("painelRecolhido", "")) document.body.classList.add("painel-recolhido");
new BotaoPainel({ position: "topleft" }).addTo(mapa);
L.control.zoom({ position: "topleft", zoomInTitle: "Aproximar", zoomOutTitle: "Afastar" }).addTo(mapa);
// O mapa muda de largura quando o painel abre ou fecha.
new ResizeObserver(() => mapa.invalidateSize()).observe($("mapa"));
const escuro = matchMedia("(prefers-color-scheme: dark)").matches;
// Com movimento reduzido pedido pelo sistema, as animações ficam mais curtas (não somem: foram pedidas).
const REDUZIR_MOVIMENTO = matchMedia("(prefers-reduced-motion: reduce)").matches;
const duracao = (ms) => (REDUZIR_MOVIMENTO ? Math.min(ms, 150) : ms);
// Roda `fim` quando a animação termina, uma vez só. O estado final não
// depende só do evento: um temporizador garante (aba em segundo plano,
// animação congelada) e um cancel() não dispara nada.
function aoTerminar(animacao, ms, fim) {
let feito = false;
const concluir = () => {
if (feito || animacao.playState === "idle") return; // cancelada
feito = true;
fim();
};
animacao.onfinish = concluir;
setTimeout(concluir, ms + 80);
}
// Mapa de fundo: Stadia Alidade Smooth, claro ou escuro conforme o tema, nos
// mesmos cinzas da página e com poucos ícones (nada de hospital em destaque
// de longe). Em 127.0.0.1/localhost funciona sem chave; publicado num domínio,
// precisa de uma chave gratuita da Stadia (https://stadiamaps.com).
L.tileLayer(`https://tiles.stadiamaps.com/tiles/${escuro ? "alidade_smooth_dark" : "alidade_smooth"}/{z}/{x}/{y}{r}.png`, {
maxZoom: 19,
attribution: '© Stadia Maps © OpenMapTiles '
+ '© OpenStreetMap',
}).addTo(mapa);
const camadaRuas = L.layerGroup().addTo(mapa); // modo "tudo": as ruas coloridas
const camadaFotos = L.layerGroup();
// As fotos só aparecem de perto: na escala da cidade, cobririam as cores das ruas.
const ZOOM_FOTOS = 15;
mapa.on("zoomend viewreset", () => {
if (dados) {
desenharTracados(); // o raio da média e a largura da linha mudaram
estilizarFotos();
}
mostrarFotos();
});
let fixos = null; // ruas e zonas, como vieram da fonte (mudam só com uma coleta)
let registro = null; // avaliações e exportações, como vieram da fonte
let dados = null; // o que o mapa desenha, montado dos dois (montarDados)
let zona = null; // a zona aberta no painel
let ruaSelecionada = null; // a rua destacada pelo clique no card da lista
let foco = 0; // índice do quadrado destacado no painel
// Esmaece as linhas e fotos de um grupo de `de` a `para` (opacidade); `fim`
// roda no final. Uma animação nova no mesmo grupo cancela a anterior.
function esmaecer(grupo, de, para, fim) {
const ms = duracao(260);
const id = (grupo._animacao = (grupo._animacao || 0) + 1);
const inicio = performance.now();
let feito = false;
const concluir = () => {
if (feito || grupo._animacao !== id) return;
feito = true;
definirOpacidade(grupo, para);
if (fim) fim();
};
const quadro = (agora) => {
if (feito || grupo._animacao !== id) return;
const t = ms ? Math.min(1, (agora - inicio) / ms) : 1;
definirOpacidade(grupo, de + (para - de) * (1 - (1 - t) ** 3)); // desacelera no fim
if (t < 1) requestAnimationFrame(quadro);
else concluir();
};
requestAnimationFrame(quadro);
setTimeout(concluir, ms + 80); // o estado final não depende dos quadros (aba em segundo plano)
}
function definirOpacidade(grupo, o) {
grupo._opacidade = o;
grupo.eachLayer((c) => {
const final = o * (c._opacidadeBase ?? 1); // _opacidadeBase: rua fora da seleção fica esmaecida
c.setStyle(c instanceof L.CircleMarker ? { opacity: final, fillOpacity: final } : { opacity: final });
});
}
// --------------------------------------------------------------------------
// Modos de exibição das avaliações
// --------------------------------------------------------------------------
const MODOS = {
ocultar: "Mapa limpo, sem nenhuma rua ou foto destacada.",
foco: "Passe o mouse numa rua avaliada para acender a avaliação em volta dele.",
tudo: "Todas as ruas avaliadas coloridas pela nota.",
};
const ORDEM_MODOS = Object.keys(MODOS);
const NEUTRA = escuro ? "#ababab" : "#6b6b6b"; // barras da lista com a avaliação oculta
let modo = lerPreferencia("modo", "tudo");
if (!(modo in MODOS)) modo = "tudo";
function escolherModo(novo) {
if (novo === modo) return;
modo = novo;
holofote.mouse = null;
holofote.lista = null;
gravarPreferencia("modo", modo);
aplicarModo(true);
}
// Aplica o modo: o indicador desliza até a opção, o texto de ajuda troca
// esmaecendo e, no mapa, as ruas e as fotos aparecem ou somem aos poucos.
function aplicarModo(animar = false) {
for (const botao of document.querySelectorAll("#modos [role=radio]")) {
const ativo = botao.dataset.modo === modo;
botao.setAttribute("aria-checked", String(ativo));
botao.tabIndex = ativo ? 0 : -1;
}
document.querySelector("#modos .indicador").dataset.posicao = ORDEM_MODOS.indexOf(modo);
// Os três textos ficam empilhados no mesmo lugar, então a seção não muda de
// altura; só o do modo escolhido aparece (troca esmaecendo, pelo CSS).
const ajuda = $("modo-ajuda");
if (!ajuda.children.length) ajuda.append(...ORDEM_MODOS.map((m) => el("span", { textContent: MODOS[m] })));
[...ajuda.children].forEach((texto, i) => texto.classList.toggle("ativo", ORDEM_MODOS[i] === modo));
$("legenda").classList.toggle("apagada", modo === "ocultar");
if (modo === "tudo" && !mapa.hasLayer(camadaRuas)) {
camadaRuas.addTo(mapa);
if (animar) { definirOpacidade(camadaRuas, 0); esmaecer(camadaRuas, 0, 1); }
} else if (modo !== "tudo" && mapa.hasLayer(camadaRuas)) {
if (animar) esmaecer(camadaRuas, 1, 0, () => camadaRuas.remove());
else camadaRuas.remove();
} else if (modo === "tudo") {
esmaecer(camadaRuas, 1, 1); // cancela um esmaecimento de saída em andamento
}
mostrarFotos(animar);
if (!dados) return;
estilizarFotos();
desenharRuas();
atualizarRuas();
}
// O controle segmentado: clique, ou setas quando ele tem o foco.
for (const botao of document.querySelectorAll("#modos [role=radio]")) {
botao.onclick = () => escolherModo(botao.dataset.modo);
}
$("modos").addEventListener("keydown", (ev) => {
const passo = { ArrowRight: 1, ArrowDown: 1, ArrowLeft: -1, ArrowUp: -1 }[ev.key];
if (!passo) return;
ev.preventDefault();
const novo = ORDEM_MODOS[(ORDEM_MODOS.indexOf(modo) + passo + ORDEM_MODOS.length) % ORDEM_MODOS.length];
escolherModo(novo);
document.querySelector(`#modos [data-modo="${novo}"]`).focus();
});
// --------------------------------------------------------------------------
// Holofote (modo "ao passar"): acende só o gradiente em volta do mouse, na
// rua avaliada mais próxima dele. Desenhado num canvas próprio, que acompanha
// o mapa; as ruas apagadas não são desenhadas.
// --------------------------------------------------------------------------
const HOLOFOTE_RAIO = 90; // px: até onde o gradiente acende em volta do mouse
const HOLOFOTE_ALCANCE = 14; // px: o mouse "está sobre a rua" até essa distância dela
const holofote = {
mouse: null, // { rua, ponto }: a rua sob o mouse e onde ele está (layer point)
lista: null, // nome da rua sob o mouse na lista: acende inteira
};
let tracados = []; // por rua avaliada: os segmentos em layer points, com a cor de cada um
mapa.createPane("holofote").style.zIndex = 390; // abaixo das fotos
const CamadaHolofote = L.Layer.extend({
onAdd(m) {
this._canvas = L.DomUtil.create("canvas", "leaflet-zoom-hide");
m.getPane("holofote").appendChild(this._canvas);
m.on("moveend zoomend resize", this._posicionar, this);
this._posicionar();
},
onRemove(m) {
this._canvas.remove();
m.off("moveend zoomend resize", this._posicionar, this);
},
_posicionar() {
const tamanho = this._map.getSize(), escala = window.devicePixelRatio || 1;
this._origem = this._map.containerPointToLayerPoint([0, 0]);
L.DomUtil.setPosition(this._canvas, this._origem);
Object.assign(this._canvas, { width: tamanho.x * escala, height: tamanho.y * escala });
Object.assign(this._canvas.style, { width: `${tamanho.x}px`, height: `${tamanho.y}px` });
this._ctx = this._canvas.getContext("2d");
this._ctx.setTransform(escala, 0, 0, escala, 0, 0);
this.redesenhar();
},
redesenhar() {
const ctx = this._ctx, o = this._origem;
ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
const alvo = alvoDoHolofote();
if (!alvo) return;
ctx.lineCap = "round";
ctx.lineWidth = larguraDaLinha();
for (const t of alvo.tracado.trechos) {
for (let i = 0; i < t.pontos.length - 1; i++) {
const a = t.pontos[i], b = t.pontos[i + 1];
let alfa = 1;
if (alvo.ponto) {
const d = alvo.ponto.distanceTo(L.point((a.x + b.x) / 2, (a.y + b.y) / 2));
if (d >= HOLOFOTE_RAIO) continue;
alfa = (1 - d / HOLOFOTE_RAIO) ** 1.5; // apaga aos poucos até a borda
}
ctx.globalAlpha = alfa;
ctx.strokeStyle = t.cores[i];
ctx.beginPath();
ctx.moveTo(a.x - o.x, a.y - o.y);
ctx.lineTo(b.x - o.x, b.y - o.y);
ctx.stroke();
}
}
ctx.globalAlpha = 1;
},
});
const camadaHolofote = new CamadaHolofote().addTo(mapa);
// O que o holofote ilumina agora: a rua da lista (inteira), a rua sob o
// mouse (em volta dele) ou, sem mouse, a rua da zona aberta (em volta da foto)
// ou a rua selecionada (inteira). No modo "Ocultar", só a rua selecionada.
function alvoDoHolofote() {
const achar = (nome) => tracados.find((t) => t.nome === nome);
if (modo === "ocultar" && ruaSelecionada && achar(ruaSelecionada)) return { tracado: achar(ruaSelecionada), ponto: null };
if (modo !== "foco") return null;
if (holofote.lista) return achar(holofote.lista) && { tracado: achar(holofote.lista), ponto: null };
if (holofote.mouse) return { tracado: achar(holofote.mouse.rua), ponto: holofote.mouse.ponto };
if (zona) {
const tracado = zona.ruas.map(achar).find(Boolean);
if (tracado) return { tracado, ponto: mapa.latLngToLayerPoint([zona.lat, zona.lon]) };
}
if (ruaSelecionada && achar(ruaSelecionada)) return { tracado: achar(ruaSelecionada), ponto: null };
return null;
}
// A rua avaliada mais perto de um ponto (layer point), se estiver a até HOLOFOTE_ALCANCE px.
function ruaPerto(p) {
let melhor = null, menor = HOLOFOTE_ALCANCE;
for (const t of tracados) {
if (!t.limites.contains(p)) continue;
for (const tr of t.trechos) {
for (let i = 0; i < tr.pontos.length - 1; i++) {
const d = L.LineUtil.pointToSegmentDistance(p, tr.pontos[i], tr.pontos[i + 1]);
if (d < menor) {
menor = d;
melhor = { tracado: t, nota: (tr.notas[i] + tr.notas[i + 1]) / 2 };
}
}
}
}
return melhor;
}
const dicaHolofote = L.tooltip({ direction: "top", offset: [0, -14], className: "dica-holofote" });
let quadroPendente = null;
mapa.on("mousemove", (ev) => {
if (modo !== "foco") return;
if (quadroPendente) cancelAnimationFrame(quadroPendente);
quadroPendente = requestAnimationFrame(() => {
quadroPendente = null;
const achou = ruaPerto(ev.layerPoint);
holofote.mouse = achou ? { rua: achou.tracado.nome, ponto: ev.layerPoint } : null;
mapa.getContainer().style.cursor = achou ? "pointer" : "";
if (achou && !fotoSobMouse) { // sobre uma foto, só a prévia dela aparece
dicaHolofote.setLatLng(ev.latlng).setContent(`${esc(achou.tracado.nome)}
nota ${formatarNota(achou.nota)}`);
if (!mapa.hasLayer(dicaHolofote)) dicaHolofote.addTo(mapa);
} else {
dicaHolofote.remove();
}
camadaHolofote.redesenhar();
});
});
mapa.on("mouseout", () => {
holofote.mouse = null;
dicaHolofote.remove();
mapa.getContainer().style.cursor = "";
camadaHolofote.redesenhar();
});
// Clique no mapa: no modo "ao passar", perto de uma rua avaliada abre a foto
// mais próxima; em qualquer outro ponto vazio, fecha o painel da zona.
// (Fotos e trechos coloridos tratam o próprio clique e não chegam aqui.)
mapa.on("click", (ev) => {
const achou = modo === "foco" && ruaPerto(ev.layerPoint);
if (achou) abrirFotoMaisProxima(achou.tracado.fotos, ev.latlng);
else if (zona) fecharZona();
else if (ruaSelecionada) selecionarRua(null);
});
// Passar o mouse (ou o foco do teclado) numa rua da lista acende a rua inteira.
function revelarRua(nome) {
if (modo !== "foco") return;
holofote.lista = nome;
atualizarRuas();
}
function esconderRua(nome) {
if (holofote.lista !== nome) return;
holofote.lista = null;
atualizarRuas();
}
// Depois de mudar o modo, a lista ou a zona aberta: redesenha o holofote.
function atualizarRuas() {
camadaHolofote.redesenhar();
for (const item of document.querySelectorAll(".rua")) item.classList.toggle("revelada", item.dataset.rua === holofote.lista);
}
// --------------------------------------------------------------------------
// Ruas e fotos no mapa
// --------------------------------------------------------------------------
// Busca os dados na fonte e redesenha o que mudou. `soAvaliacoes` reaproveita
// as ruas e zonas já carregadas; sem mudança desde a última vez, nada é
// redesenhado (a atualização periódica não mexe na tela à toa).
let assinatura = "";
async function carregar(enquadrar = false, { soAvaliacoes = false } = {}) {
try {
[fixos, registro] = await Promise.all([
soAvaliacoes && fixos ? fixos : FONTE.carregarFixos(),
FONTE.carregarAvaliacoes(),
]);
} catch (e) {
if (!dados) $("ruas").replaceChildren(el("li", { className: "vazio erro", textContent: `Não deu para carregar o mapa: ${e.message}` }));
else if (!soAvaliacoes) mostrarToast("erro", "alerta", "Não deu para atualizar o mapa", e.message);
return;
}
const nova = JSON.stringify([fixos.zonas.map((z) => [z.id, z.posicao]), fixos.ruas.map((r) => [r.nome, r.zonas, r.pendentes]),
registro.avaliacoes.map((a) => [a.ponto_id, a.posicao, a.quadrado, a.classe, a.quando]), registro.exportados.length, registro.ultima]);
if (nova === assinatura && !enquadrar) return;
assinatura = nova;
redesenhar(enquadrar);
}
function redesenhar(enquadrar = false) {
dados = montarDados(fixos, registro);
if (enquadrar && dados.ruas.length) mapa.fitBounds(limitesDe(dados.ruas), { padding: [30, 30] });
desenharTracados();
desenharFotos();
desenharRuas();
desenharProgresso();
if (zona) { // outra pessoa pode ter avaliado a zona aberta
const atual = zonaDetalhada(zona.zona);
if (atual) { zona = atual; desenharQuadrados(); }
}
}
const chaveDe = (pid, posicao, k) => `${pid}_${posicao}_${k}`;
// "2026-10-24 21:16:41.732" (UTC, do banco local) ou "2026-10-24T21:16:41.732123+00:00" (Supabase) -> ms
function instante(quando) {
let t = quando.replace(" ", "T").replace(/(\.\d{3})\d+/, "$1");
if (!/(Z|[+-]\d\d:?\d\d)$/.test(t)) t += "Z";
return Date.parse(t);
}
// Das ruas, zonas e avaliações, o que o mapa e a barra lateral mostram:
// fotos uma por (rua, zona): o ponto, os quadrados, as classes e a nota da zona
// (a média das notas dos quadrados avaliados, NOTAS)
// ruas o traçado e o resumo de cada rua
// exportacao quantas avaliações há e quantas são novas, no total e por rua
// avaliacoes a avaliação de cada quadrado da vista escolhida, por chaveDe
function montarDados({ ruas, zonas }, { avaliacoes, exportados, ultima }) {
const porChave = new Map(avaliacoes.map((a) => [chaveDe(a.ponto_id, a.posicao, a.quadrado), a]));
const exportado = new Map(exportados.map((e) => [chaveDe(e.ponto_id, e.posicao, e.quadrado), e.quando_avaliacao]));
const nova = (a) => {
const e = exportado.get(chaveDe(a.ponto_id, a.posicao, a.quadrado));
return !e || instante(a.quando) > instante(e);
};
const validas = new Map(); // só as avaliações de quadrados que estão na vista escolhida
const fotos = [];
const exportacao = { total: 0, novas: 0, ruas: {}, ultima };
for (const z of zonas) {
const classes = [];
let novas = 0;
for (const q of z.quadrados) {
const chave = chaveDe(z.id, z.posicao, q.quadrado);
const a = porChave.get(chave);
if (!a) continue;
validas.set(chave, a);
classes.push(a.classe);
if (nova(a)) novas++;
}
const notas = classes.filter((c) => c in NOTAS).map((c) => NOTAS[c]);
const contagem = {};
for (const c of classes) contagem[c] = (contagem[c] || 0) + 1;
exportacao.total += classes.length;
exportacao.novas += novas;
for (const rua of z.ruas) {
fotos.push({
rua, zona: z.id, posicao: z.posicao, lat: z.lat, lon: z.lon, endereco: z.endereco, captura: z.captura,
quadrados: z.quadrados.map((q) => q.quadrado), avaliados: classes.length, classes: contagem,
nota: notas.length ? notas.reduce((s, n) => s + n, 0) / notas.length : null,
});
if (classes.length) {
const r = (exportacao.ruas[rua] ||= { total: 0, novas: 0 });
r.total += classes.length;
r.novas += novas;
}
}
}
fotos.sort((a, b) => a.rua.localeCompare(b.rua) || a.zona - b.zona);
const resumoDas = (nome) => {
const daRua = fotos.filter((f) => f.rua === nome);
return {
com_foto: daRua.length, avaliadas: daRua.filter((f) => f.avaliados).length,
classes: Object.fromEntries(CLASSES.map((c) => [c, daRua.reduce((s, f) => s + (f.classes[c] || 0), 0)])),
};
};
return {
ruas: ruas.map((r) => ({ ...r, ...resumoDas(r.nome) })),
fotos, exportacao, avaliacoes: validas, nova,
zonas: new Map(zonas.map((z) => [z.id, z])),
};
}
// A zona como o painel mostra: a vista de contexto e os quadrados, cada um
// com a foto e a avaliação.
function zonaDetalhada(id) {
const z = dados.zonas.get(id);
if (!z) return null;
return {
...z, zona: z.id,
contexto: FONTE.imagem("contexto", `${z.id}_${z.posicao}.jpg`),
quadrados: z.quadrados.map((q) => ({
...q,
url: FONTE.imagem("quadrados", `${z.id}_${z.posicao}_${q.quadrado}.jpg`),
avaliacao: dados.avaliacoes.get(chaveDe(z.id, z.posicao, q.quadrado)) || null,
})),
};
}
function limitesDe(ruas) {
return L.latLngBounds(ruas.flatMap((r) => r.trechos.flat()));
}
function raioEmMetros() {
const metrosPorPixel = 156543.03 * Math.cos(mapa.getCenter().lat * Math.PI / 180) / 2 ** mapa.getZoom();
return Math.max(RAIO_MIN, RAIO_PX * metrosPorPixel);
}
// Nota num ponto: média das notas das fotos da rua, com peso 1 / (d² + r²),
// d a distância até a foto e r o raio do zoom. De perto (r pequeno) é uma
// interpolação pelo inverso da distância: entre duas fotos a cor passa de
// uma para a outra aos poucos, no caminho todo. De longe (r grande) as fotos
// pesam quase igual e sai a média geral da rua.
function notaEm(x, y, fotos, raio2) {
let soma = 0, pesos = 0;
for (const [fx, fy, nota] of fotos) {
const peso = 1 / ((x - fx) ** 2 + (y - fy) ** 2 + raio2);
soma += peso * nota;
pesos += peso;
}
return soma / pesos;
}
const formatarNota = (nota) => nota.toFixed(2).replace(".", ",");
// Calcula a nota de cada vértice das ruas avaliadas no zoom atual. Serve
// às duas formas de mostrar: as linhas do modo "tudo" (camadaRuas) e o
// holofote do modo "ao passar" (tracados). Ruas sem nenhuma nota não são
// desenhadas: só se vê o que já foi avaliado.
function desenharTracados() {
camadaRuas.clearLayers();
tracados = [];
const raio = raioEmMetros();
const raio2 = raio * raio;
const largura = larguraDaLinha();
const texto = (nota) => `nota ${formatarNota(nota)} · média das fotos num raio de ~${formatarDistancia(raio)}`;
for (const rua of dados.ruas) {
const latRef = rua.trechos[0][0][0];
const kx = 111320 * Math.cos(latRef * Math.PI / 180), ky = 111320;
const daRua = dados.fotos.filter((f) => f.rua === rua.nome);
const comNota = daRua.filter((f) => f.nota !== null).map((f) => [f.lon * kx, f.lat * ky, f.nota]);
if (!comNota.length) continue;
const tracado = { nome: rua.nome, fotos: daRua, trechos: [], limites: L.bounds([]) };
for (const trecho of rua.trechos) {
const notas = trecho.map(([lat, lon]) => notaEm(lon * kx, lat * ky, comNota, raio2));
const pontos = trecho.map((p) => mapa.latLngToLayerPoint(p));
pontos.forEach((p) => tracado.limites.extend(p));
tracado.trechos.push({ pontos, notas, cores: notas.slice(1).map((n, i) => corDaNota((n + notas[i]) / 2)) });
// Modo "tudo": cada segmento tem a nota média das duas pontas, num dos
// NIVEIS tons; segmentos vizinhos do mesmo tom viram uma linha só.
const tom = notas.slice(1).map((n, i) => Math.round((n + notas[i]) / 2 * NIVEIS));
let inicio = 0;
for (let j = 1; j <= tom.length; j++) {
if (j === tom.length || tom[j] !== tom[inicio]) {
const nota = tom[inicio] / NIVEIS;
const linha = L.polyline(trecho.slice(inicio, j + 1), { color: corDaNota(nota), weight: largura, opacity: 1, lineCap: "round", lineJoin: "round" });
linha.rua = rua.nome;
linha
.bindTooltip(`${esc(rua.nome)}
${texto(nota)}`, { sticky: true })
.on("click", (ev) => {
L.DomEvent.stopPropagation(ev); // não chega ao mapa (que fecharia a zona)
abrirFotoMaisProxima(daRua, ev.latlng);
})
.addTo(camadaRuas);
inicio = j;
}
}
}
// Uma margem para a busca do mouse não perder a rua na borda.
tracado.limites = L.bounds(tracado.limites.min.subtract([HOLOFOTE_RAIO, HOLOFOTE_RAIO]),
tracado.limites.max.add([HOLOFOTE_RAIO, HOLOFOTE_RAIO]));
tracados.push(tracado);
}
desenharDestaque();
camadaHolofote.redesenhar();
}
// --------------------------------------------------------------------------
// Rua selecionada (clique no card da lista): ela fica como está e o resto do
// mapa (as outras ruas e as fotos delas) esmaece. No modo "Ao passar" ela
// acende inteira; no "Ocultar", é a única rua desenhada (holofote).
// --------------------------------------------------------------------------
const ESMAECIDA = 0.25; // opacidade do que não é da rua selecionada
function desenharDestaque() {
camadaRuas.eachLayer((linha) => {
linha._opacidadeBase = ruaSelecionada && linha.rua !== ruaSelecionada ? ESMAECIDA : 1;
linha.setStyle({ opacity: (camadaRuas._opacidade ?? 1) * linha._opacidadeBase });
});
estilizarFotos();
}
// Seleciona a rua (null desfaz). Selecionar enquadra a rua no mapa.
function selecionarRua(nome) {
ruaSelecionada = nome;
for (const card of document.querySelectorAll(".rua")) {
const sim = card.dataset.rua === nome;
card.classList.toggle("selecionada", sim);
card.querySelector(".rua-principal").setAttribute("aria-pressed", String(sim));
}
if (dados) desenharDestaque();
camadaHolofote.redesenhar();
const rua = nome && dados.ruas.find((r) => r.nome === nome);
if (rua) mapa.fitBounds(limitesDe([rua]), { padding: [30, 30] });
}
// Largura da linha (px) por zoom: 80% da largura com que o mapa de fundo
// (Stadia Alidade Smooth) desenha uma rua residencial — mediana medida nos
// tiles: 1 px até o zoom 14, 2 px no 15 e 16, 3 no 17, 5 no 18 e 8 no 19. É a
// via mais estreita entre as coletadas, então a cor fica dentro de qualquer
// rua. Abaixo do zoom 15 a linha fica com 1 px (menos que isso some).
const LARGURAS = { 15: 1.6, 16: 1.6, 17: 2.4, 18: 4, 19: 6.4 };
function larguraDaLinha() {
return LARGURAS[Math.min(19, mapa.getZoom())] || 1;
}
function formatarDistancia(m) {
return m >= 1000 ? `${(m / 1000).toFixed(1).replace(".", ",")} km` : `${Math.round(m / 5) * 5} m`;
}
function abrirFotoMaisProxima(fotos, latlng) {
if (!fotos.length) return;
const maisProxima = fotos.reduce((a, b) => (mapa.distance(latlng, [a.lat, a.lon]) <= mapa.distance(latlng, [b.lat, b.lon]) ? a : b));
abrirZona(maisProxima.zona);
}
function fotosUnicas() {
// Uma zona de esquina aparece em duas ruas; no mapa, um marcador só.
const vistas = new Map();
for (const f of dados.fotos) if (!vistas.has(f.zona)) vistas.set(f.zona, f);
return [...vistas.values()];
}
function corDaFoto(f) {
if (f.nota !== null) return corDaNota(f.nota);
return f.avaliados ? CORES.nao_identificavel : "#ffffff";
}
// A dica de uma foto é uma prévia: a vista da zona e, embaixo, a zona, a
// nota (só no modo "tudo") e o endereço. A imagem tem tamanho fixo, para a
// dica não pular de lugar quando ela termina de carregar.
function previaDaFoto(marcador) {
const f = marcador.foto;
const nota = modo === "tudo" && f.nota !== null
? `${formatarNota(f.nota)}` : "";
return `
`
+ `
Zona ${f.zona}${nota}
`
+ `${esc(enderecoCurto(f.endereco))} · ${f.avaliados}/${f.quadrados.length} avaliados
`;
}
// A foto sob o mouse: enquanto houver uma, as dicas das ruas ficam fechadas
// (a da foto tem prioridade e as duas não se sobrepõem).
let fotoSobMouse = null;
// Raio das fotos por zoom: pontos discretos, que crescem um pouco de perto.
const RAIOS_FOTO = { 15: 2.5, 16: 3, 17: 3.5, 18: 4, 19: 5 };
const raioDaFoto = () => RAIOS_FOTO[Math.min(19, mapa.getZoom())] || 2.5;
function desenharFotos() {
camadaFotos.clearLayers();
for (const f of fotosUnicas()) {
const m = L.circleMarker([f.lat, f.lon], { weight: 1, color: escuro ? "#e6e6e6" : "#1f1f1f", fillOpacity: 1 });
m.foto = f;
m.zona = f.zona;
m.bindTooltip(previaDaFoto, { direction: "top", offset: [0, -8], className: "previa-foto" });
m.on("mouseover", () => {
fotoSobMouse = m;
dicaHolofote.remove();
camadaRuas.eachLayer((linha) => linha.closeTooltip());
});
m.on("mouseout", () => { if (fotoSobMouse === m) fotoSobMouse = null; });
m.on("click", (ev) => {
L.DomEvent.stopPropagation(ev); // não deixa o clique chegar ao mapa (holofote)
abrirZona(f.zona);
});
m.addTo(camadaFotos);
}
estilizarFotos();
}
// As fotos só aparecem de perto e nunca no modo "ocultar".
// O interruptor "Fotos no mapa" (o navegador lembra a escolha).
let fotosVisiveis = lerPreferencia("fotosVisiveis", "1") === "1";
function alternarFotos() {
fotosVisiveis = !fotosVisiveis;
gravarPreferencia("fotosVisiveis", fotosVisiveis ? "1" : "0");
$("alternar-fotos").setAttribute("aria-checked", String(fotosVisiveis));
mostrarFotos(true);
}
$("alternar-fotos").setAttribute("aria-checked", String(fotosVisiveis));
$("alternar-fotos").onclick = alternarFotos;
function mostrarFotos(animar = false) {
const mostrar = fotosVisiveis && mapa.getZoom() >= ZOOM_FOTOS && modo !== "ocultar";
if (mostrar && !mapa.hasLayer(camadaFotos)) {
camadaFotos.addTo(mapa);
if (animar) { definirOpacidade(camadaFotos, 0); esmaecer(camadaFotos, 0, 1); }
} else if (!mostrar && mapa.hasLayer(camadaFotos)) {
if (animar) esmaecer(camadaFotos, 1, 0, () => camadaFotos.remove());
else camadaFotos.remove();
} else if (mostrar) {
esmaecer(camadaFotos, 1, 1); // cancela um esmaecimento de saída em andamento
}
}
// Cor e tamanho das fotos: a avaliação só aparece no modo "tudo"; nos
// outros, as fotos ficam brancas (onde há foto, não como ela foi avaliada).
function estilizarFotos() {
const raio = raioDaFoto();
// Com uma rua selecionada, as fotos das outras ruas esmaecem.
const daRua = ruaSelecionada && dados ? new Set(dados.fotos.filter((f) => f.rua === ruaSelecionada).map((f) => f.zona)) : null;
camadaFotos.eachLayer((m) => {
const selecionada = zona && m.zona === zona.zona;
m._opacidadeBase = daRua && !daRua.has(m.zona) && !selecionada ? ESMAECIDA : 1;
const opacidade = (camadaFotos._opacidade ?? 1) * m._opacidadeBase;
m.setStyle({
fillColor: modo === "tudo" ? corDaFoto(m.foto) : "#ffffff",
radius: selecionada ? raio + 3 : raio,
weight: selecionada ? 2.5 : 1,
opacity: opacidade, fillOpacity: opacidade,
});
if (selecionada) m.bringToFront();
});
}
// A zona aberta: destacada no mapa e marcada na lista de zonas.
function destacarMarcador() {
estilizarFotos();
marcarZonaAtual();
}
// --------------------------------------------------------------------------
// Barra lateral
// --------------------------------------------------------------------------
// Só ruas com avaliação aparecem no mapa, então a legenda é só a escala.
function desenharLegenda() {
const gradiente = ESCALA.map(([n, c]) => `${c} ${n * 100}%`).join(", ");
$("legenda").replaceChildren(
el("div", { className: "escala" },
el("span", { className: "gradiente", style: `background:linear-gradient(to right, ${gradiente})` }),
el("div", { className: "rotulos" }, el("span", { textContent: "Sem calçada" }),
el("span", { textContent: "Inadequada" }), el("span", { textContent: "Adequada" }))),
el("p", { className: "ajuda", textContent: "De longe, a cor é a geral da rua; de perto, a de cada altura. Ruas ainda sem avaliação não aparecem." }));
}
// Para buscar nomes: sem acento, minúsculas, espaços simples.
const normalizar = (texto) => texto.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/\s+/g, " ").trim();
const casaComBusca = (nome, busca) => normalizar(nome).includes(normalizar(busca));
// "2023 Av. Sete de Setembro, Curitiba, Paraná" -> "2023 Av. Sete de Setembro"
const enderecoCurto = (endereco) => (endereco || "").split(",")[0] || "sem endereço";
// Abre ou fecha um bloco deslizando a altura e esmaecendo. Uma animação nova
// no mesmo bloco cancela a anterior; `depois` roda quando ela termina.
function animarAltura(bloco, abrir, depois) {
if (bloco._animacao) bloco._animacao.cancel();
bloco.hidden = false;
bloco.style.overflow = "hidden";
const cheio = { height: `${bloco.scrollHeight}px`, paddingTop: getComputedStyle(bloco).paddingTop, opacity: 1 };
const vazio = { height: "0px", paddingTop: "0px", opacity: 0 };
const animacao = bloco.animate(abrir ? [vazio, cheio] : [cheio, vazio],
{ duration: duracao(abrir ? 280 : 220), easing: "cubic-bezier(.2, .8, .2, 1)" });
bloco._animacao = animacao;
aoTerminar(animacao, duracao(abrir ? 280 : 220), () => {
bloco._animacao = null;
bloco.style.overflow = "";
bloco.hidden = !abrir;
if (depois) depois();
});
}
// O que está aberto na lista de ruas, guardado no navegador: as ruas com as
// zonas à mostra e os grupos ("Faltam avaliar" começa aberto, "Avaliadas"
// fechado) que o usuário trocou do padrão.
function lerConjunto(chave) {
try { return new Set(JSON.parse(lerPreferencia(chave, "[]"))); } catch { return new Set(); }
}
const ruasAbertas = lerConjunto("ruasAbertas");
const gruposTrocados = lerConjunto("gruposTrocados");
const GRUPO_ABERTO_PADRAO = { faltam: true, feitas: false };
function desenharRuas() {
if (!dados.ruas.length) {
$("ruas").replaceChildren(el("li", { className: "vazio", textContent: "Nenhuma rua coletada ainda. Use \"Coletar uma rua\", abaixo." }));
return;
}
const busca = $("busca-ruas").value;
const ruas = dados.ruas.filter((r) => casaComBusca(r.nome, busca));
if (!ruas.length) {
$("ruas").replaceChildren(el("li", { className: "vazio", textContent: `Nenhuma rua coletada com "${busca.trim()}" no nome.` }));
return;
}
$("ruas").replaceChildren(...ruas.map(itemDaRua));
}
// Um botão que abre e fecha `painel` deslizando; `aoTrocar(aberto)` grava o estado.
function ligarExpansao(botao, painel, aoTrocar) {
botao.onclick = (ev) => {
ev.stopPropagation();
const abrir = painel.hidden;
botao.setAttribute("aria-expanded", String(abrir));
aoTrocar(abrir);
animarAltura(painel, abrir);
};
}
// Uma rua da lista: o card (clique centraliza no mapa) e, pela seta no canto
// dele, as zonas, separadas entre as que faltam avaliar e as já avaliadas.
function itemDaRua(r, i) {
const mostrar = modo !== "ocultar";
const fotos = dados.fotos.filter((f) => f.rua === r.nome);
const quadrados = fotos.reduce((s, f) => s + f.quadrados.length, 0);
const avaliados = CLASSES.reduce((s, c) => s + r.classes[c], 0);
const notas = fotos.filter((f) => f.nota !== null).map((f) => f.nota);
const notaGeral = notas.length ? notas.reduce((a, b) => a + b, 0) / notas.length : null;
// Barra: quadrados por classe (com o modo "ocultar", só avaliados x não avaliados).
const barra = el("div", { className: "barra", "aria-hidden": "true" });
const fatia = (n, cor) => n && barra.append(el("span", { style: `width:${100 * n / quadrados}%;background:${cor}` }));
if (mostrar) for (const c of CLASSES) fatia(r.classes[c], CORES[c]);
else fatia(avaliados, NEUTRA);
fatia(quadrados - avaliados, "transparent");
const linha1 = el("span", { className: "linha1" }, el("span", { className: "nome", textContent: r.nome }));
if (mostrar && notaGeral !== null) {
const descricao = `Nota geral ${formatarNota(notaGeral)}, de 0 (sem calçada) a 1 (adequada)`;
linha1.append(el("span", { className: "nota", title: descricao, "aria-label": descricao },
el("span", { className: "bolinha", style: `background:${corDaNota(notaGeral)}` }), formatarNota(notaGeral)));
}
const meta = `${r.com_foto}/${r.zonas} zonas com foto · ${r.avaliadas} avaliadas` + (r.pendentes ? ` · ${r.pendentes} pendentes` : "");
const principal = el("button", { type: "button", className: "rua-principal" },
linha1, barra, el("span", { className: "meta", textContent: meta }));
principal.setAttribute("aria-pressed", String(r.nome === ruaSelecionada));
principal.title = "Destacar a rua no mapa (clique de novo para desfazer)";
principal.onclick = () => selecionarRua(r.nome === ruaSelecionada ? null : r.nome);
const aberta = ruasAbertas.has(r.nome);
const painel = el("div", { className: "zonas", id: `zonas-${i}` }, conteudoDasZonas(r, fotos, i));
painel.hidden = !aberta;
const seta = el("button", {
type: "button", className: "botao-icone pequeno expandir",
"aria-expanded": String(aberta), "aria-controls": painel.id, "aria-label": `Zonas da ${r.nome}`,
});
seta.innerHTML = icone("chevron-down");
const card = el("div", { className: "rua" + (aberta ? " aberta" : "") + (r.nome === holofote.lista ? " revelada" : "")
+ (r.nome === ruaSelecionada ? " selecionada" : "") }, principal, seta);
card.dataset.rua = r.nome;
ligarExpansao(seta, painel, (abrir) => {
card.classList.toggle("aberta", abrir);
if (abrir) ruasAbertas.add(r.nome);
else ruasAbertas.delete(r.nome);
gravarPreferencia("ruasAbertas", JSON.stringify([...ruasAbertas]));
});
// Passar o mouse ou dar foco no card também revela a rua (modo "ao passar").
card.onmouseenter = () => revelarRua(r.nome);
card.onmouseleave = () => esconderRua(r.nome);
card.addEventListener("focusin", () => revelarRua(r.nome));
card.addEventListener("focusout", (ev) => { if (!card.contains(ev.relatedTarget)) esconderRua(r.nome); });
return el("li", { className: "rua-item" }, card, painel);
}
// As zonas de uma rua em dois grupos recolhíveis: as que faltam avaliar e as avaliadas.
function conteudoDasZonas(r, fotos, i) {
if (!fotos.length) return el("div", { className: "zonas-dentro" }, el("p", { className: "nada", textContent: "Nenhuma zona com foto ainda." }));
const grupo = (tipo, titulo, lista, vazio) => {
const chave = `${r.nome}|${tipo}`;
const aberto = GRUPO_ABERTO_PADRAO[tipo] !== gruposTrocados.has(chave);
const lista_ = el("div", { className: "grupo-lista", id: `zonas-${i}-${tipo}` },
lista.length ? el("ul", {}, ...lista.map(itemDaZona)) : el("p", { className: "nada", textContent: vazio }));
lista_.hidden = !aberto;
const cabeca = el("button", { type: "button", className: "grupo-cabeca", "aria-expanded": String(aberto), "aria-controls": lista_.id },
el("span", { textContent: titulo }), el("span", { className: "num", textContent: lista.length }));
cabeca.insertAdjacentHTML("beforeend", icone("chevron-down"));
ligarExpansao(cabeca, lista_, (abrir) => {
if (abrir === GRUPO_ABERTO_PADRAO[tipo]) gruposTrocados.delete(chave);
else gruposTrocados.add(chave);
gravarPreferencia("gruposTrocados", JSON.stringify([...gruposTrocados]));
});
return el("div", { className: "grupo" }, cabeca, lista_);
};
return el("div", { className: "zonas-dentro" },
grupo("faltam", "Faltam avaliar", fotos.filter((f) => f.avaliados < f.quadrados.length), "Nenhuma: a rua toda já foi avaliada."),
grupo("feitas", "Avaliadas", fotos.filter((f) => f.avaliados === f.quadrados.length), "Nenhuma ainda."));
}
// Uma zona na lista: a cor da nota (se o modo mostra), o endereço e quantos
// quadrados já têm avaliação. Clique abre a zona.
function itemDaZona(f) {
const cor = modo !== "ocultar" && f.nota !== null ? corDaNota(f.nota) : "transparent";
const botao = el("button", { type: "button", className: "zona-item", title: f.endereco || "" },
el("span", { className: "bolinha", style: `background:${cor}` }),
el("span", { className: "endereco", textContent: enderecoCurto(f.endereco) }),
el("span", { className: "quadros", textContent: `${f.avaliados}/${f.quadrados.length}`, title: "Quadrados avaliados" }));
botao.dataset.zona = f.zona;
if (zona && zona.zona === f.zona) botao.setAttribute("aria-current", "true");
botao.onclick = () => abrirZona(f.zona);
return el("li", {}, botao);
}
// Marca na lista a zona aberta no painel.
function marcarZonaAtual() {
for (const item of document.querySelectorAll(".zona-item")) {
if (zona && Number(item.dataset.zona) === zona.zona) item.setAttribute("aria-current", "true");
else item.removeAttribute("aria-current");
}
}
function desenharProgresso() {
const unicas = fotosUnicas();
const quadrados = unicas.reduce((s, f) => s + f.quadrados.length, 0);
const avaliados = unicas.reduce((s, f) => s + f.avaliados, 0);
const fracao = quadrados ? avaliados / quadrados : 0;
$("contagem-ruas").textContent = dados.ruas.length;
$("progresso-barra").style.width = `${100 * fracao}%`;
$("progresso").textContent = unicas.length
? `${avaliados} de ${quadrados} quadrados avaliados (${Math.round(100 * fracao)}%), em ${unicas.filter((f) => f.avaliados).length} de ${unicas.length} zonas com foto.`
: "Ainda não há fotos para avaliar.";
desenharExportacao();
}
$("busca-ruas").addEventListener("input", () => dados && desenharRuas());
// --------------------------------------------------------------------------
// Exportar para conferência: um .zip que o Roboflow importa já anotado, de
// todas as ruas ou de uma (uma zona de esquina conta nas duas), com tudo ou
// só as avaliações novas: as ainda não exportadas, ou refeitas depois de
// exportadas. O zip é montado aqui na página, com as fotos da fonte.
//
// O projeto do Roboflow (apx2-bzsou) é de detecção de objetos e é baixado em
// COCO pelo treino (scripts/ingestao/download_roboflow.py e
// scripts/transformacao/extract_features.py), que lê a classe de cada imagem
// pelas anotações dela. Por isso cada quadrado vai com uma caixa cobrindo a
// imagem inteira, na classe da avaliação (NOMES_ROBOFLOW). As imagens têm o
// mesmo nome que o upload-roboflow.py usa (`____.jpg`):
// a mesma foto, mandada pelos dois caminhos, é reconhecida como duplicata.
// --------------------------------------------------------------------------
let exportarSoNovas = lerPreferencia("exportarNovas", "1") === "1";
let exportarRua = lerPreferencia("exportarRua", ""); // "" = todas as ruas
const TODAS_AS_RUAS = "Todas as ruas";
// -> "24/10 18:16" (hora local)
const dataLocal = (quando) => new Date(instante(quando))
.toLocaleString("pt-BR", { day: "2-digit", month: "2-digit", hour: "2-digit", minute: "2-digit" });
// Os quadrados avaliados que entram no zip, com o nome do arquivo: a rua
// pedida ou, numa zona de esquina, a primeira em ordem alfabética.
function quadradosParaExportar(modo, rua) {
const pastas = new Map(dados.ruas.map((r) => [r.nome, r.pasta]));
const lista = [];
for (const z of dados.zonas.values()) {
if (rua && !z.ruas.includes(rua)) continue;
const pasta = pastas.get(rua || z.ruas[0]);
for (const q of z.quadrados) {
const a = dados.avaliacoes.get(chaveDe(z.id, z.posicao, q.quadrado));
if (!a || !(a.classe in NOMES_ROBOFLOW) || (modo === "novas" && !dados.nova(a))) continue;
const nome = `${z.id}_${z.posicao}_${q.quadrado}.jpg`;
lista.push({ ponto_id: z.id, posicao: z.posicao, quadrado: q.quadrado, classe: a.classe, quando: a.quando,
url: FONTE.imagem("quadrados", nome), arquivo: pasta ? `${pasta}__${nome}` : nome });
}
}
return lista.sort((a, b) => a.ponto_id - b.ponto_id || a.quadrado - b.quadrado);
}
// O .zip: as fotos e um _annotations.coco.json. `progresso(i, n)` a cada foto baixada.
async function montarZip(lista, progresso) {
const zip = new JSZip();
const coco = {
info: { description: "Avaliações das calçadas feitas no mapa (scripts/interface)", date_created: new Date().toISOString() },
licenses: [], images: [], annotations: [],
categories: CLASSES.map((c, i) => ({ id: i + 1, name: NOMES_ROBOFLOW[c], supercategory: "calcada" })),
};
let feitas = 0;
const baixar = async (q, i) => {
const resp = await fetch(q.url);
if (!resp.ok) throw new Error(`a foto ${q.arquivo} não veio (${resp.status})`);
const blob = await resp.blob();
const bitmap = await createImageBitmap(blob);
const { width, height } = bitmap;
bitmap.close();
zip.file(q.arquivo, blob);
coco.images[i] = { id: i + 1, file_name: q.arquivo, width, height };
coco.annotations[i] = { id: i + 1, image_id: i + 1, category_id: CLASSES.indexOf(q.classe) + 1,
bbox: [0, 0, width, height], area: width * height, iscrowd: 0, segmentation: [] };
progresso(++feitas, lista.length);
};
// Seis fotos por vez.
let proxima = 0;
await Promise.all(Array.from({ length: 6 }, async () => {
while (proxima < lista.length) {
const i = proxima++;
await baixar(lista[i], i);
}
}));
zip.file("_annotations.coco.json", JSON.stringify(coco, null, 1));
return zip.generateAsync({ type: "blob", compression: "STORE" }); // JPEG já é comprimido
}
// conferencia_calcadas_2026-10-24[_rua-x][_novas].zip
function nomeDoZip(modo, rua) {
const partes = ["conferencia_calcadas", new Date().toLocaleDateString("sv-SE")]; // AAAA-MM-DD, data local
if (rua) partes.push(dados.ruas.find((r) => r.nome === rua)?.pasta || "rua");
if (modo === "novas") partes.push("novas");
return `${partes.join("_")}.zip`;
}
function desenharExportacao() {
const exp = dados.exportacao;
if (exportarRua && !(exportarRua in exp.ruas)) exportarRua = ""; // a rua não tem mais avaliações
if (document.activeElement !== $("exportar-rua")) $("exportar-rua").value = exportarRua || TODAS_AS_RUAS;
if (!$("exportar-rua-lista").hidden) desenharOpcoesRua();
$("exportar-novas").setAttribute("aria-checked", String(exportarSoNovas));
const recorte = exportarRua ? exp.ruas[exportarRua] : exp;
const n = exportarSoNovas ? recorte.novas : recorte.total;
$("exportar-texto").textContent = n
? `Exportar ${n} ${n === 1 ? "quadrado" : "quadrados"}`
: (exportarSoNovas && recorte.total ? "Nada novo para exportar" : "Nenhum quadrado avaliado");
$("exportar").disabled = n === 0;
$("contagem-novas").textContent = exp.novas || "";
const u = exp.ultima;
$("exportar-ultima").textContent = u
? `Última exportação: ${dataLocal(u.quando)} · ${u.rua || "todas as ruas"} · ${u.modo === "novas" ? "só as novas" : "tudo"} · ${u.quadrados} quadrados.`
: "Nada exportado ainda.";
}
async function exportar() {
const botao = $("exportar");
if (botao.getAttribute("aria-busy") === "true") return;
const rua = exportarRua;
const modo = exportarSoNovas ? "novas" : "tudo";
botao.setAttribute("aria-busy", "true");
$("exportar-texto").textContent = "Gerando o arquivo…";
try {
await carregar(false, { soAvaliacoes: true }); // as avaliações de agora, de todo mundo
const lista = quadradosParaExportar(modo, rua);
if (!lista.length) throw new Error(`Nenhuma avaliação${modo === "novas" ? " nova" : ""}${rua ? ` na ${rua}` : ""}: nada para exportar.`);
const blob = await montarZip(lista, (i, n) => { $("exportar-texto").textContent = `Juntando as fotos… ${i}/${n}`; });
const nome = nomeDoZip(modo, rua);
const url = URL.createObjectURL(blob);
el("a", { href: url, download: nome }).click();
setTimeout(() => URL.revokeObjectURL(url), 10000);
// Guarda o momento da avaliação que foi no zip (não o da exportação): se o
// quadrado for reavaliado enquanto o zip é montado, ele segue novo.
await FONTE.registrarExportacao(modo, rua, lista.map(({ ponto_id, posicao, quadrado, quando }) => ({ ponto_id, posicao, quadrado, quando })));
mostrarToast("sucesso", "check", "Exportado para conferência", `${lista.length} quadrados em ${nome}. No Roboflow: Upload e arraste o arquivo.`);
} catch (e) {
mostrarToast("erro", "alerta", "Não deu para exportar", e.message);
} finally {
botao.removeAttribute("aria-busy");
await carregar(false, { soAvaliacoes: true }); // as contagens de novas mudam
desenharExportacao();
}
}
$("exportar").onclick = exportar;
$("exportar-novas").onclick = () => {
exportarSoNovas = !exportarSoNovas;
gravarPreferencia("exportarNovas", exportarSoNovas ? "1" : "0");
if (dados) desenharExportacao();
};
// A rua da exportação: um combobox (padrão ARIA) que filtra as ruas enquanto
// se digita. ↑ ↓ andam pela lista, Enter escolhe, Esc fecha sem mudar.
let opcaoAtiva = -1; // índice da opção destacada pelo teclado
let filtrarRuas = false; // só filtra depois que algo foi digitado
function opcoesDeRua() {
const exp = dados.exportacao;
const busca = filtrarRuas ? $("exportar-rua").value : "";
return [["", TODAS_AS_RUAS, exp], ...Object.entries(exp.ruas).map(([nome, c]) => [nome, nome, c])]
.filter(([, rotulo]) => casaComBusca(rotulo, busca));
}
function desenharOpcoesRua() {
const lista = $("exportar-rua-lista");
const opcoes = opcoesDeRua();
opcaoAtiva = Math.min(opcaoAtiva, opcoes.length - 1);
lista.replaceChildren(...(opcoes.length ? opcoes.map(([valor, rotulo, c], i) => {
const item = el("li", { role: "option", id: `exportar-rua-op-${i}`, className: i === opcaoAtiva ? "ativa" : "",
"aria-selected": String(valor === exportarRua) },
el("span", { className: "opcao-nome", textContent: rotulo, title: rotulo }),
el("span", { className: "opcao-num", textContent: `${c.novas} ${c.novas === 1 ? "nova" : "novas"} / ${c.total}`,
title: `${c.novas} avaliações novas de ${c.total}` }));
item.addEventListener("pointerdown", (ev) => ev.preventDefault()); // não tira o foco do campo
item.onclick = () => escolherRuaExportacao(valor);
return item;
}) : [el("li", { className: "vazio", textContent: "Nenhuma rua avaliada com esse nome." })]));
$("exportar-rua").setAttribute("aria-activedescendant", opcaoAtiva >= 0 ? `exportar-rua-op-${opcaoAtiva}` : "");
lista.querySelector(".ativa")?.scrollIntoView({ block: "nearest" });
}
function abrirListaRuas() {
if (!dados) return;
$("exportar-rua-lista").hidden = false;
$("exportar-rua").setAttribute("aria-expanded", "true");
desenharOpcoesRua();
}
function fecharListaRuas() {
$("exportar-rua-lista").hidden = true;
$("exportar-rua").setAttribute("aria-expanded", "false");
$("exportar-rua").removeAttribute("aria-activedescendant");
filtrarRuas = false;
opcaoAtiva = -1;
$("exportar-rua").value = exportarRua || TODAS_AS_RUAS; // descarta o que foi digitado e não escolhido
}
function escolherRuaExportacao(valor) {
exportarRua = valor;
gravarPreferencia("exportarRua", valor);
fecharListaRuas();
desenharExportacao();
}
const campoRua = $("exportar-rua");
campoRua.addEventListener("focus", () => { campoRua.select(); abrirListaRuas(); });
campoRua.addEventListener("click", abrirListaRuas);
campoRua.addEventListener("input", () => { filtrarRuas = true; opcaoAtiva = 0; abrirListaRuas(); });
campoRua.addEventListener("blur", fecharListaRuas);
// A seta abre e fecha a lista; pointerdown sem efeito padrão: o foco fica no campo.
$("exportar-rua-seta").addEventListener("pointerdown", (ev) => ev.preventDefault());
$("exportar-rua-seta").onclick = () => {
if (!$("exportar-rua-lista").hidden) return fecharListaRuas();
if (document.activeElement === campoRua) abrirListaRuas();
else campoRua.focus(); // o focus já abre a lista
};
campoRua.addEventListener("keydown", (ev) => {
const aberta = !$("exportar-rua-lista").hidden;
if (ev.key === "ArrowDown" || ev.key === "ArrowUp") {
ev.preventDefault();
if (!aberta) return abrirListaRuas();
const n = opcoesDeRua().length;
if (n) opcaoAtiva = (opcaoAtiva + (ev.key === "ArrowDown" ? 1 : -1) + n) % n;
desenharOpcoesRua();
} else if (ev.key === "Enter") {
ev.preventDefault();
const opcao = opcoesDeRua()[Math.max(opcaoAtiva, 0)];
if (aberta && opcao) escolherRuaExportacao(opcao[0]);
} else if (ev.key === "Escape" && aberta) {
ev.stopPropagation();
fecharListaRuas();
campoRua.select();
}
});
// --------------------------------------------------------------------------
// Painel da zona: avaliação dos quadrados
// --------------------------------------------------------------------------
function abrirZona(id) {
const detalhada = dados && zonaDetalhada(id);
if (!detalhada) {
mostrarToast("erro", "alerta", "Zona não encontrada", `A zona ${id} não está no mapa.`);
return;
}
zona = detalhada;
atualizarRuas(); // modo "ao passar": o holofote vai para a foto da zona aberta
const primeiroSemAvaliacao = zona.quadrados.findIndex((q) => !q.avaliacao);
foco = primeiroSemAvaliacao >= 0 ? primeiroSemAvaliacao : 0;
$("zona-titulo").textContent = `Zona ${zona.zona} · ${zona.ruas.join(" / ")}`;
$("zona-info").textContent = [zona.endereco, zona.captura && `captura ${zona.captura}`,
zona.distancia && `carro a ${zona.distancia.toFixed(0)} m`].filter(Boolean).join(" · ");
$("zona-contexto").src = zona.contexto;
$("zona-streetview").href = zona.streetview;
desenharQuadrados();
animarPainelZona(true);
history.replaceState(null, "", `#zona=${zona.zona}`);
destacarMarcador();
centrarAoLadoDoPainel(zona.lat, zona.lon);
}
// Põe a zona no meio da parte do mapa que o painel não cobre.
function centrarAoLadoDoPainel(lat, lon) {
const z = Math.max(mapa.getZoom(), 17);
const mapaLargura = mapa.getSize().x;
const painel = $("zona").getBoundingClientRect().width;
const desvio = mapaLargura - painel > 200 ? painel / 2 : 0; // tela estreita: o painel cobre tudo mesmo
const centro = mapa.project([lat, lon], z).add([desvio, 0]);
mapa.setView(mapa.unproject(centro, z), z);
}
// O painel da zona entra deslizando da direita e sai do mesmo jeito, mais
// rápido. Com ele já aberto (troca de zona), não anima de novo; uma animação
// nova cancela a que estiver em andamento.
function animarPainelZona(abrir) {
const painel = $("zona");
const emAndamento = painel._animacao;
if (abrir && !painel.hidden && !emAndamento) return;
if (emAndamento) emAndamento.cancel();
painel.hidden = false;
const fora = { transform: "translateX(24px)", opacity: 0 };
const dentro = { transform: "none", opacity: 1 };
const ms = duracao(abrir ? 280 : 200);
const animacao = painel.animate(abrir ? [fora, dentro] : [dentro, fora],
{ duration: ms, easing: abrir ? "cubic-bezier(.2, .8, .2, 1)" : "ease-in" });
painel._animacao = animacao;
aoTerminar(animacao, ms, () => {
painel._animacao = null;
painel.hidden = !abrir;
});
}
// Clique fora do painel da zona, na barra lateral, também o fecha, menos
// numa zona da lista (que abre outra). O mapa trata os cliques dele acima.
document.addEventListener("click", (ev) => {
if (zona && !ev.target.closest("#zona, #mapa, .zona-item")) fecharZona();
});
function fecharZona() {
if (!zona) return;
animarPainelZona(false);
history.replaceState(null, "", location.pathname);
zona = null;
atualizarRuas();
destacarMarcador();
}
// O dropdown "Avaliar": aberto ou fechado (o navegador lembra) e, no
// cabeçalho, quantos quadrados já têm avaliação e a cor de cada um.
let avaliarAberto = lerPreferencia("avaliarAberto", "") === "1";
function abrirAvaliar(abrir, animar = true) {
avaliarAberto = abrir;
gravarPreferencia("avaliarAberto", abrir ? "1" : "");
$("avaliar-cabeca").setAttribute("aria-expanded", String(abrir));
if (animar) animarAltura($("avaliar-corpo"), abrir);
else $("avaliar-corpo").hidden = !abrir;
}
$("avaliar-cabeca").onclick = () => abrirAvaliar(!avaliarAberto);
function desenharResumoAvaliar() {
const feitos = zona.quadrados.filter((q) => q.avaliacao).length;
$("avaliar-resumo").replaceChildren(
...zona.quadrados.map((q) => el("span", { className: "ponto", style: `background:${q.avaliacao ? CORES[q.avaliacao.classe] : "transparent"}` })),
el("span", { textContent: zona.quadrados.length ? `${feitos}/${zona.quadrados.length}` : "sem quadrados" }));
}
function desenharQuadrados() {
desenharResumoAvaliar();
if (!zona.quadrados.length) {
$("zona-quadrados").replaceChildren(el("p", { className: "ajuda", textContent: "Esta zona não tem quadrados limpos na vista escolhida." }));
return;
}
$("zona-quadrados").replaceChildren(...zona.quadrados.map((q, i) => {
const atual = q.avaliacao?.classe;
const botoes = CLASSES.map((c, j) => {
const b = el("button", { type: "button", className: atual === c ? "ativa" : "" },
el("span", { className: "ponto", style: `background:${CORES[c]}` }), NOMES[c], el("kbd", { textContent: j + 1 }));
if (atual === c) b.style.cssText = `background:${CORES[c]};border-color:${CORES[c]}`;
b.onclick = (ev) => { ev.stopPropagation(); foco = i; avaliar(q, atual === c ? null : c); };
return b;
});
const quem = q.avaliacao
? `${q.avaliacao.origem === "modelo" ? "modelo" : "à mão"}${q.avaliacao.autor ? ` · ${q.avaliacao.autor}` : ""}`
: "sem avaliação";
const medidas = q.piso == null ? "" : `piso ${Math.round(q.piso * 100)}% · obstrução ${Math.round(q.obstrucao * 100)}%`;
const cartao = el("div", { className: "quadrado" + (i === foco ? " foco" : "") },
el("img", { src: q.url, alt: `Quadrado ${q.quadrado} da calçada`, loading: "lazy" }),
el("div", { className: "medidas", textContent: `Quadrado ${q.quadrado}${medidas ? " · " + medidas : ""}` }),
el("div", { className: "classes" }, ...botoes),
el("div", { className: "quem", textContent: quem }));
cartao.onclick = () => { foco = i; desenharQuadrados(); };
return cartao;
}));
}
async function avaliar(q, classe) {
const autor = $("autor").value.trim();
let gravada;
try {
gravada = await FONTE.avaliar(zona.zona, zona.posicao, q.quadrado, classe, autor);
} catch (e) {
mostrarToast("erro", "alerta", "Não deu para avaliar", e.message);
return;
}
// A avaliação entra nos dados já carregados: sem buscar tudo de novo.
const mesma = (a) => a.ponto_id === zona.zona && a.posicao === zona.posicao && a.quadrado === q.quadrado;
registro.avaliacoes = [...registro.avaliacoes.filter((a) => !mesma(a)), ...(gravada ? [gravada] : [])];
const proximo = zona.quadrados.findIndex((x, i) => i > foco && !x.avaliacao && x !== q);
if (classe && proximo >= 0) foco = proximo;
redesenhar(); // redesenha também os quadrados da zona aberta
}
// A próxima zona com quadrado sem avaliação, a partir da zona aberta: na rua
// pedida (o botão da rua) ou na rua da zona aberta (tecla N); se essa rua já
// estiver toda avaliada, segue pelas outras.
function proximaSemAvaliacao(rua = zona ? zona.ruas[0] : null) {
if (!dados) return;
const pendente = (f) => f.avaliados < f.quadrados.length;
const daRua = rua ? dados.fotos.filter((f) => f.rua === rua) : [];
const ordem = daRua.some(pendente) ? daRua : fotosUnicas();
const i = zona ? ordem.findIndex((f) => f.zona === zona.zona) : -1;
const proxima = [...ordem.slice(i + 1), ...ordem.slice(0, i + 1)].find(pendente);
if (proxima) abrirZona(proxima.zona);
}
document.addEventListener("keydown", (ev) => {
if (ev.target.matches("input, textarea") || ev.ctrlKey || ev.metaKey || ev.altKey) return;
if (ev.key === "n" || ev.key === "N") return proximaSemAvaliacao();
if (ev.key === "f" || ev.key === "F") return alternarFotos();
if (ev.key === "v" || ev.key === "V") return escolherModo(ORDEM_MODOS[(ORDEM_MODOS.indexOf(modo) + 1) % ORDEM_MODOS.length]);
if (ev.key === "Escape" && !zona && ruaSelecionada) return selecionarRua(null);
if (!zona) return;
if (ev.key === "Escape") return fecharZona();
if (!zona.quadrados.length) return;
// Com o "Avaliar" fechado, as teclas de avaliação só o abrem: nada é
// avaliado sem os quadrados à vista.
if (/^[0-5]$|^Arrow(Left|Right)$/.test(ev.key) && !avaliarAberto) return abrirAvaliar(true);
if (ev.key === "ArrowRight" || ev.key === "ArrowLeft") {
foco = (foco + (ev.key === "ArrowRight" ? 1 : zona.quadrados.length - 1)) % zona.quadrados.length;
ev.preventDefault();
return desenharQuadrados();
}
const n = Number(ev.key);
if (ev.key === "0") avaliar(zona.quadrados[foco], null);
else if (n >= 1 && n <= CLASSES.length) avaliar(zona.quadrados[foco], CLASSES[n - 1]);
});
$("zona-fechar").onclick = fecharZona;
try { $("autor").value = localStorage.getItem("autor") || ""; } catch {}
$("autor").addEventListener("change", () => { try { localStorage.setItem("autor", $("autor").value.trim()); } catch {} });
// --------------------------------------------------------------------------
// Coleta de uma rua
// --------------------------------------------------------------------------
let acompanhando = null; // intervalo que lê o log da coleta
let ultimaAtualizacao = 0; // quando o mapa foi recarregado durante a coleta
let previa = null; // a rua encontrada, esperando confirmação
function statusColeta(texto, erro = false) {
$("coleta-status").textContent = texto;
$("coleta-status").classList.toggle("erro", erro);
}
// Primeiro passo: acha a rua e mostra quantas zonas faltam, como o menu do terminal.
async function procurarRua(nome) {
$("coleta-candidatas").hidden = true;
$("form-confirmar").hidden = true;
statusColeta("Procurando a rua…");
try {
previa = await api("/api/coleta/previa", { nome });
} catch (e) {
statusColeta(e.message, true);
const candidatas = e.dados?.candidatas;
if (candidatas) {
$("coleta-candidatas").replaceChildren(...candidatas.map((c) => {
const b = el("button", { type: "button", className: "botao", textContent: c });
b.onclick = () => { $("coleta-nome").value = c; procurarRua(c); };
return b;
}));
$("coleta-candidatas").hidden = false;
}
return;
}
statusColeta("");
$("confirmar-texto").textContent = `"${previa.nome}": ${previa.zonas} zonas, ${previa.processadas} já processadas, ${previa.a_fazer} a processar.`;
$("coleta-limite").max = previa.a_fazer;
$("coleta-limite").value = "";
$("form-confirmar").querySelector("button[type=submit]").disabled = previa.a_fazer === 0;
$("form-confirmar").hidden = false;
}
// Segundo passo: roda a coleta da rua confirmada.
async function iniciarColeta() {
try {
const estado = await api("/api/coleta", { nome: previa.nome, limite: $("coleta-limite").value });
$("form-confirmar").hidden = true;
mostrarColeta(estado);
acompanharColeta();
} catch (e) {
statusColeta(e.message, true);
}
}
// O andamento da coleta, lido do log do subprocesso: a etapa atual ("== 2/3
// ...", ou "== Publicando no site", do publicar.py) e, dentro dela, o último
// contador "[i/n]".
const ETAPAS = { 1: "Procurando os panoramas", 2: "Baixando as fotos", 3: "Conferindo as calçadas" };
function andamentoDoLog(log) {
let etapa = null, fracao = null;
for (const linha of log) {
const e = linha.match(/^== (\d)\/3 /) || linha.match(/^== (Publicando)/);
if (e) { etapa = e[1] === "Publicando" ? "publicar" : Number(e[1]); fracao = null; continue; }
const p = linha.match(/\[(\d+)\/(\d+)\]/);
if (p && etapa) fracao = Number(p[1]) / Number(p[2]);
}
return { etapa, fracao };
}
// Em vez do log, um carregamento: spinner, a etapa e uma barra (que anda
// sozinha enquanto a etapa não informa quanto falta).
function mostrarColeta(estado) {
$("coleta-procurar").disabled = estado.rodando;
$("coleta-parar").hidden = !estado.rodando || estado.publicacao === "publicando"; // "Parar" é só da coleta
$("coleta-andamento").hidden = !estado.rodando;
if (estado.rodando) $("secao-coleta").open = true;
if (!estado.rua) return;
const minutos = Math.round(((estado.fim || Date.now() / 1000) - estado.inicio) / 60);
if (estado.rodando) {
const { etapa, fracao } = andamentoDoLog(estado.log);
const publicando = etapa === "publicar";
$("coleta-titulo").textContent = publicando ? `Publicando ${estado.rua} no site`
: `Coletando ${estado.rua}${estado.limite ? ` (${estado.limite} zonas)` : ""}`;
$("coleta-etapa").textContent = (publicando ? "Enviando as fotos novas e as zonas"
: etapa ? `Etapa ${etapa} de 3 · ${ETAPAS[etapa]}` : "Preparando") + ` · ${minutos} min`;
$("coleta-trilho").classList.toggle("indeterminado", fracao === null);
$("coleta-barra").style.width = fracao === null ? "" : `${100 * fracao}%`;
if (fracao === null) $("coleta-trilho").removeAttribute("aria-valuenow");
else $("coleta-trilho").setAttribute("aria-valuenow", Math.round(100 * fracao));
statusColeta(FONTE.site ? "As fotos aparecem no mapa quando a coleta terminar." : "As fotos aparecem no mapa ao fim de cada etapa.");
return;
}
const textos = {
concluida: `Última coleta: ${estado.rua}, ${minutos} min${estado.resumo ? ` · ${estado.resumo}` : ""}.`,
interrompida: `Coleta de ${estado.rua} interrompida. Rodar de novo continua de onde parou.`,
erro: `A coleta de ${estado.rua} parou com erro${estado.erro ? `: ${estado.erro}` : "."}`,
};
const publicacao = { publicada: " Publicada no site.", erro: ` Não deu para publicar no site: ${estado.erro_publicacao}` };
statusColeta((textos[estado.situacao] || "") + (publicacao[estado.publicacao] || ""),
estado.situacao === "erro" || estado.publicacao === "erro");
}
// O aviso de fim de coleta, no canto superior direito.
function avisarFimDaColeta(estado) {
const avisos = {
concluida: ["sucesso", "check", estado.publicacao === "publicada" ? "Coleta concluída e publicada" : "Coleta concluída",
`${estado.rua}${estado.resumo ? ` · ${estado.resumo}` : ""}`],
interrompida: ["atencao", "pause", "Coleta interrompida", `${estado.rua}. Rodar de novo continua de onde parou.`],
erro: ["erro", "alerta", "A coleta parou com erro", estado.erro || estado.rua],
};
if (avisos[estado.situacao]) mostrarToast(...avisos[estado.situacao]);
if (estado.publicacao === "erro") mostrarToast("erro", "alerta", "Não deu para publicar no site", estado.erro_publicacao || "");
}
// Toast: some sozinho depois de TOAST_MS (o tempo para enquanto o mouse ou o
// foco estiver nele) e tem um × para fechar antes.
const TOAST_MS = 1500;
function mostrarToast(tipo, nomeIcone, titulo, texto) {
const fechar = el("button", { type: "button", className: "botao-icone pequeno", "aria-label": "Fechar o aviso" });
fechar.innerHTML = icone("x");
const toast = el("div", { className: `toast ${tipo}`, role: tipo === "erro" ? "alert" : "status" },
el("span", { className: "toast-icone" }),
el("div", { className: "toast-texto" }, el("b", { textContent: titulo }), el("span", { textContent: texto })),
fechar);
toast.querySelector(".toast-icone").innerHTML = icone(nomeIcone);
$("toasts").append(toast);
let saindo = false;
const sair = () => {
if (saindo) return;
saindo = true;
clearTimeout(temporizador);
const animacao = toast.animate([{ opacity: 1, transform: "none" }, { opacity: 0, transform: "translateX(16px)" }],
{ duration: duracao(180), easing: "ease-in" });
aoTerminar(animacao, duracao(180), () => toast.remove());
};
let temporizador = setTimeout(sair, TOAST_MS);
const pausar = () => clearTimeout(temporizador);
const retomar = () => { if (!saindo && !toast.matches(":hover, :focus-within")) temporizador = setTimeout(sair, TOAST_MS); };
toast.addEventListener("mouseenter", pausar);
toast.addEventListener("focusin", pausar);
toast.addEventListener("mouseleave", retomar);
toast.addEventListener("focusout", retomar);
fechar.onclick = sair;
toast.animate([{ opacity: 0, transform: "translateX(16px)" }, { opacity: 1, transform: "none" }],
{ duration: duracao(220), easing: "cubic-bezier(.2, .8, .2, 1)" });
}
function acompanharColeta() {
if (acompanhando) return;
acompanhando = setInterval(async () => {
let estado;
try { estado = await api("/api/coleta"); } catch { return; }
mostrarColeta(estado);
if (estado.rodando && !FONTE.site && Date.now() - ultimaAtualizacao > 20000) {
ultimaAtualizacao = Date.now();
carregar();
}
if (!estado.rodando) {
clearInterval(acompanhando);
acompanhando = null;
avisarFimDaColeta(estado);
carregar(); // com o site, as zonas que a publicação mandou
}
}, 2000);
}
$("form-coleta").onsubmit = (ev) => {
ev.preventDefault();
procurarRua($("coleta-nome").value.trim());
};
$("form-confirmar").onsubmit = (ev) => {
ev.preventDefault();
iniciarColeta();
};
$("confirmar-cancelar").onclick = () => { $("form-confirmar").hidden = true; previa = null; };
$("coleta-parar").onclick = async () => mostrarColeta(await api("/api/coleta/parar", {}));
// --------------------------------------------------------------------------
desenharLegenda();
aplicarModo();
abrirAvaliar(avaliarAberto, false);
// As seções recolhíveis abrem e fecham deslizando e lembram se ficaram
// abertas (a da coleta começa fechada). O conteúdo de cada uma vai para um
// bloco próprio, que é o que anima.
for (const secao of document.querySelectorAll("details.recolhivel")) {
const resumo = secao.querySelector("summary");
const conteudo = el("div", { className: "conteudo" });
conteudo.append(...[...secao.children].filter((filho) => filho !== resumo));
secao.append(conteudo);
const salvo = lerPreferencia(`aberta:${secao.id}`, "");
if (salvo) secao.open = salvo === "1";
resumo.addEventListener("click", (ev) => {
ev.preventDefault();
if (secao.open && !secao.classList.contains("fechando")) {
secao.classList.add("fechando");
animarAltura(conteudo, false, () => {
secao.open = false;
conteudo.hidden = false; // o fechado já esconde
secao.classList.remove("fechando");
});
} else {
secao.classList.remove("fechando");
secao.open = true;
animarAltura(conteudo, true);
}
});
secao.addEventListener("toggle", () => gravarPreferencia(`aberta:${secao.id}`, secao.open ? "1" : "0"));
}
// O endereço guarda a vista (#mapa=zoom/lat/lon) ou a zona aberta (#zona=),
// para mandar o link de um trecho ou de uma zona a alguém.
const zonaNoEndereco = location.hash.match(/^#zona=(\d+)$/);
const vistaNoEndereco = location.hash.match(/^#mapa=(\d+)\/(-?[\d.]+)\/(-?[\d.]+)$/);
if (vistaNoEndereco) mapa.setView([Number(vistaNoEndereco[2]), Number(vistaNoEndereco[3])], Number(vistaNoEndereco[1]));
mapa.on("moveend", () => {
if (zona) return;
const c = mapa.getCenter();
history.replaceState(null, "", `#mapa=${mapa.getZoom()}/${c.lat.toFixed(5)}/${c.lng.toFixed(5)}`);
});
carregar(!zonaNoEndereco && !vistaNoEndereco).then(() => zonaNoEndereco && abrirZona(Number(zonaNoEndereco[1])));
// A coleta só existe no servidor do computador que coleta (o .exe ou python
// -m scripts.interface), que marca `coleta` no config.js; no site, a seção
// fica escondida.
if (window.CONFIG?.coleta) {
api("/api/coleta").then((estado) => {
$("secao-coleta").hidden = false;
mostrarColeta(estado);
if (estado.rodando) acompanharColeta();
}).catch(() => {});
}
// Outras pessoas avaliam ao mesmo tempo: o mapa se atualiza a cada minuto
// com a aba à vista, e quando ela volta a ficar à vista.
setInterval(() => { if (document.visibilityState === "visible" && FONTE.site) carregar(false, { soAvaliacoes: true }); }, 60000);
document.addEventListener("visibilitychange", () => { if (document.visibilityState === "visible" && dados) carregar(); });