[C/C++/Java] Codice per curve B-Spline e Bezier

[di@!]

ok funge, ora provo a smanettare un po vediamo che viene fuori

[di@!]

ok, ti dico subito che quest'ultimo codice che c'hai dato è mostruoso, addirittura non c'è nemmeno bisogno di ricompilare ogni volta, basta che cambi i valori in general path e aggiorna la curva al volo...potrebbe essere esattamente quello che cercavamo, volevo chiederti una cosa però

noi abbiamo i punti di controllo su coordinate x,y..e su generalpath ho la funzioni

curve.moveTo(0, 0); (da dove la faccio partire, coordinate x e y)
curve.curveTo(100, 200, 300, 400, 500, 600); (passa per i punti xxx, ma cmq questa funzione accetta sempre e solo 6 punti, se io ne ho di meno o di più?)

me le spieghi un secondo? se io ho i punti di controllo come coordinate x,y come le inserisco in queste funzioni?

update: ok mi son letto un po di cose qua e la...generalpath è usato per disegnare una curva di bezier, ma con 3 coordinate, mentre noi ne abbiamo 4...suppongo non si possa ampliare il numero di punti di controllo utilizzabili

[PGI-Bis]

Puoi tentare la manovra del maiale

Grufoli in rete cercando un algoritmo che faccia al caso tuo e lo copi bellamente: è una porcata (da cui il nome della mossa) colossale ma... si fa .

Ad esempio in rete

http://www.ibiblio.org/e-notes/Splines/Basis.htm

ho trovato un codice francamente illeggibile ma che tradotto in JavaScript x Java diventa:

//drawcurve.js
function drawCurve() {
		CANVAS.clear();
		graphics = CANVAS.getBufferGraphics();
		graphics.setColor(java.awt.Color.BLACK);
		var w = 512;
		var h = 512;
		var w2 = w;
		var h1 = h - 1;
		var n = 4; //numero di punti
		var k = 3; //ordine
		var n1 = n + 1;
		var nt = n + k + 1;
		/* Coordinate dei punti di controllo (origine in basso a sinistra,
		x cresce verso destra, y cresce verso l'alto */
		var Px = new Array(100.0, 400.0, 400.0, 300.0, 200.0);
		var Py = new Array(50.0, 50.0, 400.0, 300.0, 400.0);
		
		var ti = new Array(nt + k);
		for(var i = 0; i < nt + k; i++) {
			if(i < nt) {
				ti[i] = i;
			} else {
				ti[i] = 0;
			}
		}
		var N = new Array(nt + 1);
		for(var i = 0; i < nt + 1; i++) {
			N[i] = new Array(w2);
		}
		
		var to = ti[0];
		
		var dt = ti[nt-1]-to;
		
		for(var i = 0; i < nt; i++) {
			ti[i] = w2 + w2 * (ti[i] - to) / dt;
		}
		
		//	DRAW FUN
		var step = (ti[nt - 1] - ti[0]) / (w2 - .9);
		
		var t = ti[0];
		
		var Tmin = java.lang.Math.round(((ti[k - 1] - ti[0]) / step) + 1);
		var Tmax = java.lang.Math.round(((ti[n1] - ti[0]) / step));
		var i1 = 0;
		
		for(var l = 0; l < w2; l++) {
			while(t >= ti[i1]) {
				i1++;
			}
			
			var i = i1 - 1;
			
			for(var j = 0; j < nt; j++) {
				N[j][l] = 0;
			}
			
			N[i][l] = 1;
			
			for(var m = 2; m <= k; m++) {
				var jb = i - m + 1;
				if(jb < 0) {
					jb = 0;
				}
				for(var j = jb; j <= i; j++) {
					N[j][l] = N[j][l]*(t - ti[j]) / (ti[j + m - 1] - ti[j])
						+ N[j + 1][l] * (ti[j + m] - t) / (ti[j + m] - ti[j+1]);
				}
			}
			
			t += step;
		}
		var X, Y;
		
		for(var i = 0; i < n1; i++) {
			X = Px[i];
			Y = h1 - Py[i];
			graphics.drawRect(X - 1, Y - 1, 3, 3);
			var label = "C" + java.lang.Math.round(i);
			graphics.drawString(label, X - 1, Y - 1);
		}
		var sX = 0.0;
		var sY = 0.0;
		for(var j = 0; j < n1; j++) {
			sX += Px[j]*N[j][Tmin];
			sY += Py[j]*N[j][Tmin];
		}
		var Xold = sX;
		var Yold = h1 - sY;
		for(k = Tmin + 1; k <= Tmax; k++) {
			sX = 0;
			sY = 0;
			for(var j = 0; j < n1; j++) {
				sX += Px[j]*N[j][k];
				sY += Py[j]*N[j][k];
			}
			X = sX;
			Y = h1-sY;
			if((X < w2) && (Xold < w2)) {
				graphics.drawLine(Xold, Yold, X, Y);
				Xold = X;
				Yold = Y;
			}
		}
		CANVAS.flush();
}

In grassetto ci sono le parti che dovresti provare a smanacciare. n è il numero di punti, Px e Py sono le coordinate (x e y) dei punti di controllo.

L'ho provato e funziona ma avendolo io suinamente tradotto non so assolutamente perchè faccia quel che fa.

[di@!]

ti ringrazio anche al nome del mio amico, sei stato gentilissimo

regola del maiale2win