BAC.bars con su razonamiento y sus matemáticasBAC.bars en siete pasos. Aquí se explica cada función nueva de cada paso con tres bloques: el razonamiento (qué problema resuelve), las matemáticas (por qué la cuenta es esa) y, cuando hay que despejar, la balanza: lo que se hace en un plato se hace en el otro. Los números son los del nivel 17 (lienzo de 600 × 250, Ene … Jun).escala() y bandas()pasoRedondo() y maximoRedondo()barra(): esquinas con curvastween(), easeOut() y escalon()BAC.bars: qué parámetro es cada cosa(x − x0) está dividiendo. Multiplico los dos platos por (x − x0) y a la izquierda se anula:
− y0. Sumo y0 en los dos platos:
const x0 = 48, x1 = 588; // izquierda y derecha const y0 = 222, y1 = 22; // base y techo const hueco = (x1 - x0) / n; // 90 const ancho = hueco * 0.55; // 49,5 const x = map(i, 0, n, x0, x1) + (hueco - ancho) / 2; const y = map(v, 0, max, y0, y1);
escala(): la recta con los extremos ya fijadosfunction escala([d0, d1], [p0, p1]) {
return (v) => map(v, d0, d1, p0, p1);
}
const y = escala([0, max], [H - m.b, m.t]); // [0, 4800] → [222, 22]
y(3200) // 222 − 3200/24 = 88,67
map() con cinco números cada vez, y cuatro eran siempre los mismos (0, max, y0, y1). escala() los fija una vez y devuelve una función nueva que solo pide lo que cambia: el dato. A una función que «recuerda» variables de donde se creó se le llama clausura (closure): la flecha (v) => … sigue viendo d0, d1, p0, p1 cuando escala ya ha terminado.[d0, d1] en los parámetros son desestructuración: se le pasa un array de dos elementos y los separa en dos variables. Se leen como «dominio» (datos) y «rango» (píxeles), como en D3.
map es una función de cinco variables. Si se fijan cuatro, queda una recta de una sola variable, de la forma y(v) = a + b·v:
y(3200) = 222 − 3200/30 = 115,33: la barra baja porque el techo de la escala ha subido.bandas(): el reparto horizontalfunction bandas(n, x0, x1, hueco) {
const paso = (x1 - x0) / n; // tu "hueco" del nivel 1
const ancho = paso * (1 - hueco); // hueco .45 → la barra ocupa el 55 %
return {
ancho,
x: (i) => x0 + i * paso + (paso - ancho) / 2,
centro: (i) => x0 + i * paso + paso / 2
};
}
paso. Ahora hueco es la parte vacía del carril (45 %). Por eso ancho = paso · (1 − 0,45) = 0,55 · paso, el mismo resultado que hueco * 0.55 del paso 1. Devuelve un objeto con dos funciones: dónde empieza la barra (x) y dónde está su centro (centro, para los textos).
x(i) es lo mismo que el map() del paso 1(paso − ancho)/2:
ancho/2 a los dos lados de x(i) (el centro de una barra que empieza en x(i) y mide ancho):
pasoRedondo(): el escalón «bonito» del ejefunction pasoRedondo(rango, cuantos = 4) {
const bruto = rango / cuantos;
const potencia = Math.pow(10, Math.floor(Math.log10(bruto)));
const k = bruto / potencia; // entre 1 y 10
return (k < 1.5 ? 1 : k < 3 ? 2 : k < 7 ? 5 : 10) * potencia;
}
function maximoRedondo(max) {
const paso = pasoRedondo(max);
return Math.ceil(max / paso) * paso;
}
const max = maximoRedondo(Math.max(...datos) * 1.08); // 4800 → 5184 → 6000
Math.ceil(max / paso) * pasoy(v) = 222 − v · 200/6000 = 222 − v/30. Junio: 222 − 160 = 62 (ya no toca el techo, 22).
Prueba con otros máximos:
barra(): un <path> que se dibuja como con un lápizfunction barra(x, y, w, h, r) {
if (h <= 0) return '';
r = Math.min(r, h, w / 2); // el radio no puede ser mayor que la barra
return `M${x},${y + h} V${y + r} Q${x},${y} ${x + r},${y} H${x + w - r} Q${x + w},${y} ${x + w},${y + r} V${y + h} Z`;
}
M = mueve el lápiz sin pintar · V = línea vertical hasta esa y · H = línea horizontal hasta esa x · Q = curva hasta un punto, «tirada» hacia un punto de control · Z = cierra volviendo al inicio. La barra se recorre: abajo-izquierda → sube → curva → techo → curva → baja → cierra.Math.min(r, h, w/2): si la barra mide 2 de alto, un radio de 4 se saldría por abajo; si mide 6 de ancho, dos radios de 4 se cruzarían. El radio se limita a lo que cabe.
Q (Bézier cuadrática)Q une P0 con P2 tirando hacia P1 (el control). Cada punto de la curva es una media ponderada de los tres:
tween(), easeOut() y escalon()// tween.js: llama a update(t) en cada fotograma, con t de 0 a 1
var t = Math.min((now - start) / (seconds * 1000), 1);
function easeOut(t) { return 1 - (1 - t) * (1 - t); }
function escalon(t, i, n, solape = .35) {
const inicio = n > 1 ? i / (n - 1) * solape : 0;
const local = Math.max(0, Math.min(1, (t - inicio) / (1 - solape)));
return easeOut(local);
}
const alto = (y(0) - y(datos[i])) * escalon(t, i, datos.length);
requestAnimationFrame). En cada uno se calcula qué fracción del tiempo ha pasado: t = 0 al empezar, t = 1 a los 1,2 s. La gráfica no sabe de tiempo, solo de t.d del path en cada fotograma y parece que crece.easeOut arranca rápido y frena al final, como algo que se detiene.t = solape y tiene que acabar en t = 1. Su duración es lo que queda: 1 − solape. Si todas duran lo mismo, todas duran 1 − 0,35 = 0,65. Para cada barra quiero un «t local» que valga 0 cuando empieza y 1 cuando acaba: es la misma recta de siempre, de [inicio, inicio + 0,65] a [0, 1]:
local saldría negativo y después de acabar, mayor que 1: Math.max(0, Math.min(1, …)) lo «pinza» entre 0 y 1 (clamp).
const cambio = v / datos[i - 1] - 1;
if (cambio < -0.03) avisos[i] = '−' + Math.round(-cambio * 100) + ' %';
tip.style.left = e.clientX + 14 + 'px'; tip.style.top = e.clientY - 50 + 'px';
const yRef = y(datos[0]); // la baseline
crear('text', { x: x.centro(+i), y: y(datos[i]) - 7, class: 'flag' }); // el aviso, encima
render de og1.js (allí el umbral es el 20 %).<div> fuera del SVG que sigue al ratón. clientX/clientY es la posición del ratón en la ventana; +14 y −50 lo separan del puntero para no taparlo.BAC.bars: cada opción es uno de los pasosBAC.bars(document.getElementById('g7'), {
labels: meses, // los textos del eje x (paso 1)
values: datos, // las alturas (pasos 1–3)
refs: [{ value: datos[0], label: `Baseline ene · ${V.fmt(datos[0])}` }], // paso 6
flags: avisos, // paso 6
tip: (i) => `<b>${V.fmt(datos[i])}</b>${meses[i]}` // paso 6
});
| paso | lo que hiciste a mano | en las librerías |
|---|---|---|
| 1 | map(), x0/x1/y0/y1, hueco, ancho | dentro de BAC.bars (tu estilo del nivel 10) |
| 2 | escala(), bandas() | V.escala, V.bandas |
| 3 | pasoRedondo(), maximoRedondo(), corto() | V.maximoRedondo, V.marcas, V.corto |
| 4 | barra() | V.barra |
| 5 | tween(), escalon() | tween.js, V.animar, V.escalon |
| 6 | avisos, tooltip, línea de referencia | opciones flags, tip, refs |
Math.min(r, h, w/2) lo para?local = (0,35 − 0,35)/0,65 = 0.−0.05: ¿sigue saliendo abril? (−4,88 % no es menor que −5 %.)