Migliorare getSVG1() - Campionamento adattivo delle curve Bézier

Il problema

La funzione getSVG1() di CostyCNC converte i contorni generati da Potrace in G-code. Tuttavia, la versione attuale ha un limite: prende i 3 punti di controllo della Bézier e li collega con 3 comandi G01 lineari.

Geometricamente, questo non è la curva: è una spezzata che passa per i punti di controllo. La curva reale passa accanto a quei punti, non attraverso di essi.

La soluzione: campionamento adattivo con tabella

Invece di usare un numero fisso di punti (es. 8), si decide in base alla lunghezza del segmento: più il segmento è lungo, più punti servono.

La formula è:

N = clamp( ceil(lunghezza / tolleranza), N_min, N_max )

Dove:

• lunghezza = lunghezza approssimata del segmento (poligono di controllo)
• tolleranza = errore massimo accettabile in mm (es. 0.2 mm)
• N_min = numero minimo di punti (es. 4)
• N_max = numero massimo di punti (es. 24)

Perché usare una tabella precalcolata

Invece di calcolare la formula di de Casteljau a ogni punto (con potenze e moltiplicazioni), si possono usare coefficienti precalcolati per ogni valore di t.

Come calcolare la lunghezza del segmento

La lunghezza approssimata della Bézier si stima con la distanza tra i punti di controllo (poligono di controllo):

L ≈ |P0-P1| + |P1-P2| + |P2-P3|

Questa è una sovrastima della lunghezza reale, ma è veloce da calcolare e va benissimo per decidere N.

Il codice completo

Sostituisci la funzione bezier(i) dentro getSVG1() con questa versione, che usa la tabella precalcolata:

// Tabella dei coefficienti per t = 1/8, 2/8, ..., 7/8
// (valori arrotondati a 4 decimali)
var coeffs8 = [
    [0.6699, 0.2871, 0.0410, 0.0020],
    [0.4219, 0.4219, 0.1406, 0.0156],
    [0.2441, 0.4395, 0.2637, 0.0527],
    [0.1250, 0.3750, 0.3750, 0.1250],
    [0.0527, 0.2637, 0.4395, 0.2441],
    [0.0156, 0.1406, 0.4219, 0.4219],
    [0.0020, 0.0410, 0.2871, 0.6699]
];

function bezier(i) {
    var b = "";

    // P0 = punto finale del segmento precedente
    var P0x, P0y;
    if (i === 0) {
        P0x = curve.c[(curve.n - 1) * 3 + 2].x * sizex;
        P0y = curve.c[(curve.n - 1) * 3 + 2].y * sizey;
    } else {
        P0x = curve.c[(i - 1) * 3 + 2].x * sizex;
        P0y = curve.c[(i - 1) * 3 + 2].y * sizey;
    }

    var P1x = curve.c[i * 3 + 0].x * sizex;
    var P1y = curve.c[i * 3 + 0].y * sizey;
    var P2x = curve.c[i * 3 + 1].x * sizex;
    var P2y = curve.c[i * 3 + 1].y * sizey;
    var P3x = curve.c[i * 3 + 2].x * sizex;
    var P3y = curve.c[i * 3 + 2].y * sizey;

    // --- Lunghezza approssimata (poligono di controllo) ---
    var d01 = Math.sqrt((P1x-P0x)*(P1x-P0x) + (P1y-P0y)*(P1y-P0y));
    var d12 = Math.sqrt((P2x-P1x)*(P2x-P1x) + (P2y-P1y)*(P2y-P1y));
    var d23 = Math.sqrt((P3x-P2x)*(P3x-P2x) + (P3y-P2y)*(P3y-P2y));
    var lunghezza = d01 + d12 + d23;

    // --- Configurazione ---
    var N_base     = 8;      // valore di riferimento
    var N_min      = 4;      // minimo assoluto
    var N_max      = 24;     // MASSIMO ASSOLUTO
    var tolleranza = 0.2;    // mm (regola in base alla tua macchina)

    // --- Calcola N in base alla lunghezza ---
    var N;
    if (lunghezza < 1.0) {
        N = N_min;          // curve molto corte: 4 punti
    } else if (lunghezza < 5.0) {
        N = N_base;         // curve medie: 8 punti
    } else {
        N = Math.ceil(lunghezza / tolleranza);
        if (N < N_base) N = N_base;
        if (N > N_max)  N = N_max;
    }

    // --- Se N non è 8, usa la formula di de Casteljau ---
    // (per N=8 usiamo la tabella precalcolata)
    if (N === 8) {
        // Tabella precalcolata (più veloce)
        for (var k = 0; k < coeffs8.length; k++) {
            var c = coeffs8[k];
            var x = c[0]*P0x + c[1]*P1x + c[2]*P2x + c[3]*P3x;
            var y = c[0]*P0y + c[1]*P1y + c[2]*P2y + c[3]*P3y;
            b += 'G01 X' + x.toFixed(3) + ' Y' + y.toFixed(3) + '\n';
        }
    } else {
        // Formula di de Casteljau (per N diverso da 8)
        for (var j = 1; j <= N; j++) {
            var t = j / N;
            var mt = 1 - t;
            var x = mt*mt*mt * P0x + 3*mt*mt*t * P1x + 3*mt*t*t * P2x + t*t*t * P3x;
            var y = mt*mt*mt * P0y + 3*mt*mt*t * P1y + 3*mt*t*t * P2y + t*t*t * P3y;
            b += 'G01 X' + x.toFixed(3) + ' Y' + y.toFixed(3) + '\n';
        }
    }

    // Punto finale
    b += 'G01 X' + P3x.toFixed(3) + ' Y' + P3y.toFixed(3) + '\n';
    return b;
}

Come scegliere la tolleranza

Comportamento risultante

Vantaggi rispetto a un numero fisso di punti

• Segmenti corti → pochi punti (4-6), file compatto
• Segmenti medi → 8 punti (tabella, veloce)
• Segmenti lunghi → fino a 24 punti, curva fedele
• File G-code → più piccolo del 30-50% rispetto a 8 punti fissi
• Qualità → uniforme su tutto il percorso

Bonus: adattivo anche sulla curvatura

Se vuoi il massimo, puoi combinare lunghezza e curvatura:

// Stima della curvatura: quanto si discosta il punto medio della curva
// dalla corda P0-P3
var mx = 0.125*P0x + 0.375*P1x + 0.375*P2x + 0.125*P3x;
var my = 0.125*P0y + 0.375*P1y + 0.375*P2y + 0.125*P3y;
var cx = (P0x + P3x) / 2;
var cy = (P0y + P3y) / 2;
var curvatura = Math.sqrt((mx-cx)*(mx-cx) + (my-cy)*(my-cy));

// Punti in base a lunghezza E curvatura (sempre max 24)
var N = Math.ceil((lunghezza + curvatura * 4) / tolleranza);
if (N < 4)  N = 4;
if (N > 24) N = 24;

Questo aggiunge punti extra solo dove la curva è più "curva", ottimizzando ancora di più, ma senza mai superare i 24 punti.

Riepilogo

Need more help?

Sito CostyCNC GitHub