Newsgroup: it.comp.lang.c++
Titolo: problema di interpolazione in realtime

ho una sequenza di eventi (numeri) che vengono letti a tempi indefiniti (o
meglio, questi eventi sono generati dall'utente).
con una buona probabilita` questi (numeri) saranno consecutivi. es.:
5..12...20..25...32.......38....20.....12...11.10....
__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|__
io vorrei generare un output, a un rate costante, che sia il risultato
dell'interpolazione della sequenza di numeri, ovvero vorrei che il grafico
dell'output risulti quanto piu` "liscio" possibile. (perdonatemi il
termine inappropriato.. ^_^)
ovviamente cio` deve avvenire in tempo reale, e quindi non posso
indovinare ne` il numero che arrivera`, ne` in che momento arrivera`...
che tipo di algoritmo posso usare?
[ho provato a incrementare V (l'output corrente) di meta` del delta tra V0
e V1 (due valori consecutivi), ma questo produce un andamento logaritmico
"A SCATTI"...]
grazie!

xaero wrote:

Non ho capito bene cosa tu abbia fatto per produrre un andamento 
"logaritmico" (forse intendevi esponenziale? :) ), ma senza addentrarci 
in cose non proprio facilissime come le spline potresti utilizzare una 
semplicissima interpolazione lineare.
Si tratta semplicemente di fare la differenza tra il valore appena 
arrivato e quello precedente, dividere questa differenza per il numero 
di "unita' temporali" trascorse tra i due campioni e poi sommare questo 
incremento ad ogni campione intermedio. Tanto per buttare giu' 2 righe 
di codice, supponendo che i tuoi campioni gia' interpolati stiano in una 
lista, farai una cosa del tipo:
void interpolate(float newSample, int ticks, list<float>* samples){
	float& oldSample = samples->back();
	float diff = newSample - oldSample;
	float dsdt = diff / ticks;
	float intermediateSample = oldSample;
	for(int i=0; i<ticks; i++){
		intermediateSample += dsdt;
		samples->push_back(intermediateSample);
	}
}

 }
grazie per il suggerimento.
conosco l'interpolazione lineare, tuttavia essa non produce una curva tra
i punti, ma un'insieme di segmenti (rette).
ne deriva che la velocita(1) con cui varia il valore dell'output V, e` in
funzione del tempo (delta T) e del valore output (delta V).
siccome (per questioni di "ambiente") devo operare in tempo reale, e senza
buffer(*), forse una soluzione potrebbe essere quella di simulare
un'inerzia di questa velocita(1)... ma non so con quale algoritmo di
interpolazione.
(*) la mia situazione sarebbe piu` del tipo:
float V = 0.0;    // valore di output corrente
float dest = 0.0; // memorizzo valore richiesto
float C = 1.35;   // coefficiente velocita
void tick(float newVal) {
  dest += newVal;
  float delta = dest - newVal;
  V += delta / C;
}
(con questo esempio credo che la funzione della velocita sia l'iperbole...
quale tipo di interpolazione sarebbe piu' adatta allo scopo?)

risolto
applicando questo algoritmo con piu' iterazioni (piu' di una volta)
ottengo una specie di passa basso.
(tral'altro ho sbagliato a scrivere il codice di esempio, che dovrebbe
essere stato:)
float V = 0.0;    // valore di output corrente
float dest = 0.0; // memorizzo valore richiesto
float C = 1.35;   // coefficiente velocita
void tick(float newVal) {
  dest = newVal;
