De tus fórmulas a graficas-base.js y graficas-ba.js
Idea: tus niveles (barras/, donut/, calor/…) y las librerías de los OG usan las mismas dos fórmulas: la rectamap() y la circunferenciapunto(). Las librerías no inventan matemáticas: reordenan las tuyas y añaden unas pocas ideas nuevas (la recta al revés, la curva suave, el ángulo «de reloj», el color por tramos…). Aquí se compara cada gráfica tuya con su versión de la librería y se explica cada diferencia con razonamiento, matemáticas y, cuando hay que despejar, con la balanza.
tus dos fórmulas en graficas-base.js (V)
map(x, x0, x1, y0, y1) = y0 + (x−x0)·(y1−y0)/(x1−x0)
→ V.map, V.escala, V.bandas, V.marcas…
punto(r, a) = [cx + r·cos a, cy + r·sin a] → V.punto, V.puntoReloj, V.arco
En tus niveles los datos los escribes tú y nunca son todos 0. En los OG los datos vienen de GA4, y una tarjeta puede recibir todo ceros (sin tráfico ese mes) o un solo punto (una línea con un mes). Entonces max = 0 o n − 1 = 0, y la recta tiene los dos extremos iguales.
Matemáticas
Si x1 = x0, el denominador vale 0. En JavaScript, 0/0 = NaN y 5/0 = Infinity, y un atributo y="NaN" hace que el SVG no pinte la forma. Geométricamente, con dos puntos en la misma vertical no hay una recta que sea función de x: la pendiente no existe. El seguro devuelve y0, el principio del intervalo: con todo ceros, todas las barras se quedan en la base.
2 · LÍNEAS Y ÁREAS · NUEVO
escala().invertir: del píxel al dato
function escala([d0, d1], [p0, p1]) {
const f = (dato) => map(dato, d0, d1, p0, p1); // dato → píxel (lo de siempre)
f.invertir = (pixel) => map(pixel, p0, p1, d0, d1); // píxel → dato (NUEVO)
return f;
}
// en BAC.lines y BAC.area: ¿sobre qué mes está el ratón?
const i = V.limitar(Math.round(x.invertir(V.raton(svg, e).x)), 0, n - 1);
Razonamiento
Tus gráficas solo van en un sentido: del dato sale el píxel. En los OG, al pasar el ratón por una línea se muestra el tooltip del mes más cercano. Ahí el camino es el contrario: del píxel del ratón hay que sacar el mes. Es la función inversa.
Balanza · despejar x en la recta
Partimos de la recta y queremos dejar x sola (ahora conocemos y, el píxel):
y = y0 + (x − x0) · (y1 − y0) / (x1 − x0)
Pesada 1: resto y0 en los dos platos:
y − y0 = (x − x0) · (y1 − y0) / (x1 − x0)
Pesada 2: multiplico los dos platos por (x1 − x0) / (y1 − y0), el inverso de la fracción:
Una barra ocupa un espacio (un carril). Una línea pasa por puntos, y el primero y el último deben quedar en los bordes. Es el problema de los postes y la valla: con 12 postes hay 11 tramos de valla. Barras → divides entre n; puntos → entre n − 1. La librería hace lo mismo que tú: V.bandas para las barras y V.escala([0, n−1]) para las líneas.
Matemáticas
barras: paso = (x1 − x0) / n el índice n (que no existe) cae en x1
puntos: paso = (x1 − x0) / (n − 1) el índice n − 1 (el último) cae en x1
Si en la línea usaras map(i, 0, n, …), el último punto quedaría a un paso del borde derecho; si en las barras usaras n − 1, la última barra se saldría.
4 · LÍNEAS Y ÁREAS
V.curva: la curva suave y el misterioso 1/6
// es tu curva() de barras/variantes-lineas.html, línea por línea
const c1 = [p1[0] + (p2[0] - p0[0]) / 6, p1[1] + (p2[1] - p0[1]) / 6];
const c2 = [p2[0] - (p3[0] - p1[0]) / 6, p2[1] - (p3[1] - p1[1]) / 6];
d += `C${c1} ${c2} ${p2}`;
Razonamiento
La polilínea (M … L … L) hace «picos» en cada dato. Una curva que pase por todos los puntos y no tenga picos necesita que, en cada punto, la dirección de llegada y la de salida sean la misma. La regla de Catmull-Rom dice qué dirección usar en p1: la de la cuerda entre sus vecinos, de p0 a p2.
Matemáticas · dos datos de partida
(a) Catmull-Rom: la tangente (velocidad) en p1 es la mitad de la cuerda entre vecinos: T1 = (p2 − p0) / 2. (b) Bézier cúbica (C): sale de p1 con velocidad B′(0) = 3 · (c1 − p1) y llega a p2 con B′(1) = 3 · (p2 − c2).
Balanza · igualar velocidades y despejar c1
3 · (c1 − p1) = (p2 − p0) / 2 las dos velocidades en p1 son la misma
Pesada 1: divido los dos platos entre 3:
c1 − p1 = (p2 − p0) / 6
Pesada 2: sumo p1 en los dos platos:
c1 = p1 + (p2 − p0) / 6 ✓ (el 6 sale de 2 · 3)
Igual en la llegada: 3 · (p2 − c2) = (p3 − p1)/2 → ÷3 → p2 − c2 = (p3 − p1)/6 → paso c2 a un plato y lo demás al otro → c2 = p2 − (p3 − p1)/6. En los extremos falta un vecino y se usa el propio punto (puntos[i − 1] || puntos[i]).
5 · LÍNEAS · NUEVO
La línea que «se dibuja»: stroke-dashoffset y easeInOut
const largo = trazo.getTotalLength(); // cuánto mide la línea, en unidades del SVG
trazo.style.strokeDasharray = largo; // una raya tan larga como la línea… y un hueco igual
V.animar(1.4, t => { trazo.style.strokeDashoffset = largo * (1 - t); }, { curva: easeInOut });
Razonamiento
Tus líneas aparecen de golpe. En BAC.lines, la línea se convierte en un discontinuo con una sola raya del largo exacto del trazo. Desplazando esa raya (dashoffset) desde «fuera» (largo) hasta su sitio (0), parece que un lápiz la va dibujando.
Matemáticas
visible = largo − offset = largo − largo·(1 − t) = largo · t
(la parte dibujada crece en línea recta con t)
easeInOut(t) = t² · (3 − 2t) velocidad = derivada = 6t(1 − t)
→ velocidad 0 al principio y al final, máxima (1,5) a la mitad
Frente a easeOut (barras), easeInOut también arranca suave: queda mejor en algo que «viaja» por la pantalla.
6 · ÁREAS
Tu área baja a la base; la de la librería tiene un borde de abajo
tu nivel 3
area = linea +
'L ' + final[0] + ',' + y0 +
'L ' + primero[0] + ',' + y0 + 'Z';
Tu área cierra bajando a la base (y0). En las áreas apiladas, la segunda capa no empieza en la base sino encima de la primera. Por eso la librería guarda dos bordes: bajo (donde empieza la capa) y alto = bajo + valor. Con bajo = 0 es exactamente tu área.
El borde de abajo se recorre al revés (reverse): se va por arriba de izquierda a derecha y se vuelve por abajo de derecha a izquierda. Si se recorrieran los dos en el mismo sentido, el contorno se cruzaría en forma de «Z».
Matemáticas · la animación con clipPath
ancho de la máscara = (W − m.l) · t (la recta de [0, 1] a [0, W − m.l])
Un rectángulo invisible que recorta el área crece de izquierda a derecha y va «destapando» el dibujo, que ya está completo debajo.
7 · AGRUPADAS
El ancho de cada barra del grupo, despejado
tu nivel 5
anchoBarra = (anchoGrupo - separacion * (series.length - 1))
/ series.length;
x = inicioGrupo + si * (anchoBarra + separacion);
Es la misma fórmula con otros nombres: tu anchoGrupo es x.ancho (de V.bandas), tu separacion = 4 es HUECO = 2, y tu inicioGrupo es x.x(i). La única diferencia es que las barras de la librería tienen las esquinas redondeadas y crecen en cascada.
Balanza · ¿cuánto mide cada barra?
En el ancho del grupo caben k barras y k − 1 huecos entre ellas:
k · anchoBarra + (k − 1) · HUECO = ancho
Pesada 1: resto (k − 1) · HUECO en los dos platos:
El corazón es idéntico: cada trozo empieza donde acabó el anterior. La librería añade tres cosas: Modo 100 % (pct: true): cada valor se divide entre el total de su columna, y el máximo del eje pasa a ser 1. Todas las columnas miden lo mismo y se comparan las proporciones. Crecer: cada valor se multiplica por escalon(t, i, n). Como todos los trozos de la columna se multiplican por el mismo número, la columna crece entera sin cambiar sus proporciones. Detalles: 2 px de hueco entre trozos y solo el trozo de arriba con esquinas redondeadas (radio 4; los demás, 0).
Matemáticas · por qué multiplicar todos por t no deforma
t·a + t·b + t·c = t · (a + b + c) (propiedad distributiva)
El total de la columna es el total multiplicado por t, y cada trozo sigue siendo la misma fracción del total: t·a / (t·total) = a / total, porque las t se anulan.
9 · DONUT
El ángulo de cada trozo también es una recta
tu 07-donut
var angulo = d.valor / total * 2 * Math.PI;
var a0 = inicio, a1 = inicio + angulo;
inicio = a1; // empezaba en −π/2
Tú calculas el tamaño del trozo y lo vas sumando al inicio. La librería calcula directamente dónde empieza y dónde acaba cada trozo, convirtiendo el acumulado de valores en un ángulo con la recta: valor 0 → 0 rad, total → 2π. Se llega al mismo sitio.
Balanza · la recta con origen en 0 es una regla de tres
map(a, 0, total, 0, 2π) = 0 + (a − 0) · (2π − 0) / (total − 0)
= a · 2π / total = a / total · 2π
Es tu fórmula, valor / total · 2π, aplicada al acumulado. Y el tamaño del trozo sale restando los dos platos:
a1 − a0 = (acum + v)/total · 2π − acum/total · 2π
= v / total · 2π ← tu "angulo"
Matemáticas · la bandera arcoGrande y el hueco
En el comando A de SVG, entre dos puntos de una circunferencia hay dos arcos posibles: el corto y el largo. arcoGrande = 1 si el trozo pasa de media vuelta (π); tú y la librería lo calculáis igual. La librería resta además HUECO = 0,025 rad (≈ 1,4°) al final de cada trozo, en vez de usar un borde blanco como haces tú.
function punto(r, a) {
return [cx + r * Math.cos(a), cy + r * Math.sin(a)];
}
function angulo(p) { return Math.PI + p / 100 * Math.PI; }
graficas-base.js · BAC.gauge
function puntoReloj(cx, cy, r, a) {
return punto(cx, cy, r, a - Math.PI / 2);
}
const angulo = (v) => V.map(v, 0, 1, -Math.PI / 2, Math.PI / 2);
Razonamiento
En matemáticas el ángulo 0 está a las 3 (a la derecha). Los donuts y gauges se piensan como un reloj: empiezan a las 12. Tú lo arreglas en cada gráfica (inicio = −π/2 en el donut, π + … en el medidor). La librería lo arregla una vez dentro de puntoReloj, que resta π/2, y así todas las gráficas piensan en «hora de reloj». Ojo: como en pantalla la y crece hacia abajo, al aumentar el ángulo el punto gira en el sentido del reloj, no al revés como en el papel.
Balanza · tu gauge y el de la librería dan los mismos ángulos
Tu ángulo (matemático) para p % es π + p/100 · π. El de la librería (reloj) es map(v, 0, 1, −π/2, π/2) = −π/2 + v · π, y puntoReloj le resta π/2:
La diferencia entre los dos platos es π − (−π) = 2π: una vuelta entera, que en un círculo no cambia nada (cos y sin se repiten cada 2π). Son el mismo punto: v = 0 a las 9, v = 0,5 a las 12, v = 1 a las 3.
Matemáticas · la marca del objetivo
Tu medidor y BAC.gauge la dibujan igual: dos puntos con el mismo ángulo y distinto radio (uno por dentro y otro por fuera del anillo). Al compartir ángulo, la rayita queda en la dirección del centro (radial).
Con opacidad, un solo azul se mezcla con el fondo: si el fondo cambia (tema oscuro), cambian los colores, y los valores bajos casi no se distinguen entre sí. La librería primero lleva el valor a k entre 0 y 1 (tu misma recta) y luego recorre una escala de tres colores: casi blanco → azul medio → azul oscuro. Son dos rectas, una para cada mitad.
Además, el número de cada celda cambia a blanco cuando k > 0,42, porque el fondo ya es lo bastante oscuro.
Balanza · ¿de dónde sale el × 200?
En la primera mitad quiero llevar k de [0; 0,5] a un porcentaje de [0; 100]:
Son las dos rectas del código. En k = 0,5 las dos dan el mismo color (azul 500 puro): los tramos empalman sin salto.
tu opacidad (de 0,08 a 1):
seqColor (dos tramos):
12 · EMBUDO, RANKING, TABLA Y TONOS
Cuando la gráfica es HTML, la recta da porcentajes
rellenos.push({ ancho: p.value / max * 100 }); // funnel: % del primer paso
filas.push({ ancho: it.value / max * 100 }); // rank: % del mayor
const k = Math.round(V.map(i, 0, n - 1, 0, gama.length - 1)); // tone: posición → color de la gama
Razonamiento
El embudo, el ranking y la tabla no son SVG: son <div> con width: N%. No hacen falta píxeles, porque el porcentaje ya se adapta al ancho del contenedor. La recta lleva el valor de [0, máximo] a [0, 100]. tone() usa la recta para escoger un color de una lista: de la posición i (0 … n − 1) a un índice de la gama (0 … 4), redondeado porque un índice no puede tener decimales.
Balanza · el porcentaje y la caída del embudo
map(v, 0, max, 0, 100) = v · 100 / max
(otra recta con origen en 0 = regla de tres)
caída = (anterior − v) / anterior = 1 − v / anterior
(se separa la fracción, como en el nivel 19)
El «peor paso» es simplemente el de mayor caída: se recorren los pasos y se guarda el máximo.
13 · TOOLTIP · NUEVO
V.raton: el viewBox también es una recta
function raton(svg, evento) {
const p = svg.createSVGPoint();
p.x = evento.clientX; p.y = evento.clientY;
return p.matrixTransform(svg.getScreenCTM().inverse()); // pantalla → unidades del viewBox
}
Razonamiento
Tu SVG mide 600 unidades, pero en pantalla puede ocupar 320 px (móvil) o 900 px. El ratón da píxeles de pantalla (clientX), y la escala x.invertir espera unidades del viewBox. getScreenCTM() es la conversión que el navegador aplica al dibujar (unidades → pantalla); su inverse() hace el camino de vuelta.
Balanza · la conversión es otra recta
Sin giros, el navegador dibuja así (a = escala, e = dónde empieza el SVG en la pantalla):
pantalla = a · unidad + e (por ejemplo, a = 900/600 = 1,5 y e = 120)
Pesada 1: resto e en los dos platos → pantalla − e = a · unidad Pesada 2: divido entre a → unidad = (pantalla − e) / a