geom2d

geom2d — Riferimento API

Libreria 2D per geometria piana. Fornisce Punto2 (punto), Linea2 (segmento) e getptsoffset (offset tra percorsi).

Tolleranza globale: TOLL = 1e-3.

---

Punto2

Rappresenta un punto nel piano cartesiano.

Costruttore

new Punto2(x, y)       // coordinate separate
new Punto2([x, y])      // array
new Punto2({x, y})      // oggetto

Tutti i formati producono {x: numero, y: numero}. Valori mancanti o non numerici vengono forzati a 0.

Proprietà (getter)

Proprietà	Tipo	Descrizione
dump	string	Rappresentazione {x,y} con 1 decimale
len2	number	Quadrato della distanza dall’origine
len	number	Distanza dall’origine
angle	number	Angolo del vettore rispetto all’asse X (radianti)

Metodi

dir() → Punto2

Vettore normalizzato (lunghezza unitaria). Se il punto è l’origine, restituisce se stesso.

const v = new Punto2(3, 4);
v.dir();  // Punto2(0.6, 0.8)

distanza(p1) → number

Distanza euclidea tra this e p1.

const a = new Punto2(0, 0);
const b = new Punto2(3, 4);
a.distanza(b);  // 5

angolo3p(p2, p3) → number

Angolo in gradi (0–180) con vertice in this, formato dai segmenti this→p2 e this→p3.

puntosucerchio(r, ang) → Punto2

Punto su una circonferenza di raggio r centrata in this, all’angolo ang (gradi).

const c = new Punto2(10, 10);
c.puntosucerchio(5, 90);  // punto a ore 12, raggio 5

tangentesucerchio(r, ang, l) → Linea2

Segmento tangente alla circonferenza di raggio r centrata in this, all’angolo ang. Lunghezza l (default 100).

---

Linea2

Segmento definito da due punti p1 e p2.

Costruttore

new Linea2(x1, y1, x2, y2)   // 4 coordinate
new Linea2({x,y}, {x,y})       // 2 oggetti punto
new Linea2(p1, p2)             // 2 Punto2

Proprietà (getter)

Proprietà	Tipo	Descrizione
dump	string	{x1,y1}-{x2,y2}
dx	number	p2.x - p1.x
dy	number	p2.y - p1.y
len2	number	Quadrato della lunghezza
len	number	Lunghezza del segmento
angle	number	Sinonimo di angolo() senza argomenti
direzione	Punto2	Vettore direzione normalizzato
normale	Punto2	Vettore normale normalizzato (ruotato +90°)

Metodi — Intersezione e proiezione

interseca(line2) → Punto2 | null

Punto di intersezione tra le due rette (infinite). null se parallele.

intersezione(line2)

Alias di interseca.

proiezione(p) → Punto2 | undefined

Proiezione ortogonale del punto p sulla retta (infinita). undefined se segmento degenere.

proiezionet(p) → {p: Punto2, t: number} | undefined

Come proiezione ma restituisce anche t: parametro normalizzato (0 = p1, 1 = p2, <0 = prima di p1, >1 = oltre p2).

onsegment(p, eps?) → boolean

true se il punto p giace sul segmento (collineare + tra gli estremi). Tolleranza default 1e-9.

distanzaPunto(p) → number

Distanza minima tra punto p e segmento. Se la proiezione cade fuori, distanza dall’estremo più vicino.

Metodi — Angoli e parallelismo

angolo(line2?) → number

Con argomento: angolo orientato da this a line2 (radianti, in [-π, π]). Senza argomento: angolo del segmento rispetto all’asse X.

isparallela(line2) → boolean

Tolleranza interna di ±1 sul determinante.

isperpendicolare(line2) → boolean

Prodotto scalare < TOLL.

isCollineare(line2, checkPuntiComuni?) → boolean

Segmenti sulla stessa retta. Se checkPuntiComuni=true, verifica anche la sovrapposizione.

Metodi — Offset e parallele

offset(delta) → Linea2

Nuovo segmento parallelo traslato di delta. Positivo = sinistra, negativo = destra.

const base = new Linea2(0, 0, 100, 0);
base.offset(10);  // Linea2(0,10)-(100,10)

parallela(p1, lunghezza) → Linea2

Segmento parallelo a this, passante per p1, lunghezza specificata.

offsetline(l) → Linea2

Offset lungo la normale ortogonale di distanza l. Restituisce nuovo segmento.

distanzaSegmentiParalleli(line2) → number

Distanza tra due segmenti paralleli. 1e9 se non paralleli.

Metodi — Perpendicolari

perpendicolare(p?, lunghezza?) → Linea2

Segmento perpendicolare a this. Se p è omesso, parte da p1. Lunghezza default = len.

perpendicolaret(t, lunghezza?) → Linea2

Come perpendicolare ma parte dal punto al parametro t (0 = p1, 1 = p2, 0.5 = metà).

Metodi — Punti su segmento

puntot(t) → Punto2

Punto sul segmento al parametro t (0 = p1, 1 = p2).

puntosudirezione(p1, lunghezza) → Punto2

Punto a distanza lunghezza da p1 lungo la direzione del segmento.

Metodi — Rotazione

ruotata(angle, length?, fine?) → Linea2

Nuovo segmento ruotato di angle (radianti). length default = len.

• fine=false: ruota attorno a p1
• fine=true: ruota attorno a p2
• fine=Punto2: segmento ruotato passante per quel punto

rotatedonp1(angle) → Linea2

Rotazione in gradi attorno a p1.

rotatedonp2(angle) → Linea2

Rotazione in gradi attorno a p2.

rotate(deg) → this

Ruota il segmento di deg gradi attorno all’origine. Mutazione in-place.

Metodi — Estensione e lunghezza

estendi(l) → Linea2

• Se l è numero: allunga (l>0) o accorcia (l<0) il segmento di l unità.
• Se l è Linea2: estende fino all’intersezione con l’altra linea.

const s = new Linea2(0, 0, 10, 0);
s.estendi(5);   // Linea2(0,0)-(15,0)
s.estendi(-3);  // Linea2(-3,0)-(10,0)

setlunghezza(l)

Imposta la lunghezza a l, mantenendo p1 fisso. Mutazione in-place.

Metodi — Traslazione

move(x, y) → this

Trasla di (x, y). Accetta anche move({x, y}). Mutazione in-place.

Metodi — Info sul quadrilatero

infoquad(line2) → Object | undefined

Se i due segmenti sono paralleli, restituisce:

{
  angle,    // angolo base (gradi)
  aini,     // angolo lato sinistro (gradi)
  afin,     // angolo lato destro (gradi)
  l,        // lunghezza base
  ltot,     // lunghezza totale proiettata
  distanza, // distanza tra le rette
  sx, sy    // coordinate p1 arrotondate
}

undefined se non paralleli.

lunghezzatotale(line2) → number

Lunghezza totale proiettata dei due segmenti paralleli sulla direzione comune.

Utilità

clone() → Linea2

Copia indipendente del segmento.

ortopt(l) → {x, y}

Punto a distanza l dalla retta nella direzione della normale, partendo da p1.

---

getptsoffset(pt, pt2, delta)

Calcola i punti di offset tra due percorsi (array di punti). Usato per estrarre il tratto di un percorso che corrisponde all’offset del primo.

Parametri

Parametro	Tipo	Descrizione
pt	Array<{x,y}>	Percorso originale (almeno 2 punti)
pt2	Array<{x,y}>	Percorso offset (almeno 2 punti)
delta	number	Distanza di offset

Restituisce

Array<{x,y}> — punti del percorso offset corrispondenti. Vuoto se non trova corrispondenza.

Funzionamento

1. Calcola l’offset del primo e ultimo segmento di pt tramite Linea2.offset(delta)
2. Cerca in pt2 segmenti collineari con questi offset
3. Restituisce il percorso più breve tra i due punti di corrispondenza

Esempio

const originale = [{x:0,y:0}, {x:10,y:0}, {x:10,y:10}];
const offset   = [{x:0,y:5}, {x:10,y:5}, {x:10,y:15}];
const tratto = getptsoffset(originale, offset, 5);
// tratto: [{x:0,y:5}, {x:10,y:5}, {x:10,y:15}]

---

Note

• Tutti gli angoli nei costruttori/metodi che accettano gradi sono esplicitamente documentati. Punto2.angle e Linea2.angolo() usano radianti.
• rotate() e move() mutano l’oggetto. Preferire clone() prima se serve preservare l’originale.
• ruotata() restituisce un nuovo oggetto.
• TOLL (1e-3) è usato per confronti di parallelismo, collinearità e intersezioni. Per onsegment la tolleranza è separata (default 1e-9).