[C++] Interpretare un buffer di dati come una gesture 1D

[Alessio17]

Salve a tutti,
Fino ad ora ho creato un programma (sul compilatore Qt) che apre una porta seriale e riceve da un sensore di prossimità il valore della distanza rilevata ed ho creato un grafico su cui plotta in real-time i dati che riceve.
Quello che vorrei fare ora è far interpretare al mio programma una serie di dati decrescente (o crescente) come una mia azione, a cui quindi collegare un'azione da svolgere.
Avevo pensato di creare per l'appunto un buffer di dati,p.e. creare un array a grandezza fissata che raccoglie dei valori e li interpreta, se sono decrescenti attivare una funzione (pensavo ad uno switch tra più immagini).
Ancora su questa parte del programma non ho scritto nulla, anche perché non so bene come muovermi. Qualcuno ha qualche idea o consiglio?
Se serve vedere qualche parte del codice scritto fino ad ora, posso postarlo tranquillamente.

[Alessio17]

Oggi sono riuscito a scrivere a parte un programmino che mi mostra a schermo un 'led' che cambia colore se si preme un pulsante.
Non sono però riuscito ancora a risolvere il problema della gesture 1D. Qualcuno sa come potrei far interpretare al mio programma una serie di dati decrescenti come una mia azione per fare click?

[Alessio17]

Ho implementato il mio programma 'terminal' con un led che al cliccare del bottone "cambia", cambia colore al led.

#include"luce.h"
#include"ui_luce.h"
#include<QHBoxLayout>
#include<QPushButton>
#include<qled.h>
#include<QVector>

Luce::Luce(QWidget*parent):QWidget(parent),
ui(newUi::Luce)
{
ui->setupUi(this);
on_pushButton_released();
}

Luce::~Luce()
{    deleteui;
}

intrandNum(intmin,intmax)
{r
eturnrand()%max+min;
}

voidLuce::on_pushButton_released()
{
QList<QLed*>tis=findChildren<QLed*>();
foreach(QLed*led,tis)
       {
QLed::ledColorcol=(QLed::ledColor)randNum(QLed::ledColor::Red,QLed::ledColor::Blue);
led->setOffColor(col);
        }
}

voidLuce::gesture(intresult)
{ 
//funzione che riceve il dato result contenente la misurazione della distanza
}

Quello che avevo in mente era creare un array od un vector che contenesse una quantità fissata di dati e, tramite un ciclo if la cui istruzione prevede di andare a controllare il primo e l'ultimo valore dell' array/vector e, se il primo è maggiore del secondo, passare alla funzione on_pushButton_released() che cambia colore in modo casuale al led.
Una cosa tipo questa:

QVector <int> valore[500];
// int primo = valore[0];
//int ultimo = valore[500];
if (primo > ultimo)
        {
             on_pushButton_released();
         }

Questo è un codice scritto qui sul momento, non so se è corretto come sintassi o come ragionamento, attendo vostre opinioni. Grazie.

[Alessio17]

Giorno a tutti,
Ho riscritto quell'accenno di codice per renderlo un po' più leggibile:

intvalore[1000]={0};

for(inti=0;i<1001;i++)
{
valore[i]=result;
}
intprimo=valore[0];
intultimo=valore[999];

qDebug()<<primo<<ultimo<<endl;

if(primo>ultimo)
{
on_pushButton_released();
}
else{
return;
}

Qt però va in crash e si chiude forzatamente, sapete spiearmi perché? Come potrei risolvere?

[linoma]

Probabilmente se provi a vedere il tuo vettore in ottica di rapporto incrementale puoi capire il crescere o il decrescere della tua fx. Più fine è il tuo calcolo migliore sarà l'indice angolare

[Alessio17]

Ciao,
lavorandoci un po' su sono arrivato a questa forma del codice (che , per fortuna, non si blocca):

intvalore[3]={0};
intprimo=0;
intsuccessivo=0;
for(inti=0;i<3;i++)
{
if(i==0)
{
//successivo=primo;
valore[0]=50;
//qDebug()<<"questoèif"<<endl;}
else
{
valore[i]=result;    //èilvalorenellaposizioneida1->max(1000)
successivo=valore[i];
primo=valore[i-1]; //primocambiavaloreconl'attualevaloredi'valore'
//qDebug()<<primo<<successivo<<endl;
if((primo>successivo)&&(primo!=2000))
{
//qDebug()<<"Questoèprimo="<<primo<<"Questoèsuccessivo:"<<successivo<<endl;
on_pushButton_released();
}
}
}

In realtà ora come ora sto girando intorno al problema, perché succede sempre che 'successivo' si memorizza valore[0] anche se l'indice cambia (ora 3 è il massimo, ma capita anche per i = 3000), mentre primo cambia valore e risulterà quasi sempre maggiore.