[c++] che vuol dire questa istruzione?

[vermaccio]

in cima al listato, insomma nel blocco iniziale dove si definiscono le variabili etc etc c'è questo. che vuol dire?

#define BALL(R, G, B) (R >= 250 && G < 20 && B < 5)?TRUE:FALSE

che vuol dire?


e in seguito nel "main" c'è l'istruzione

if (BALL(R(P),G(P),B(P))) {...blablabla...
}

quando è che l'if attiva il "blablabla" e quando no?

[shinya]

E' una macro, che in C++ è consigliabile sostituire con una funzione inline.
Nel caso specifico, se R >= 250 && G < 20 && B < 5 ritorna true, altrimenti false.
Mi pare piuttosto intuitivo...

[vermaccio]

<<E' una macro>>

questo volevo sapere, altrimenti non avevo idea di cosa cercare nel manualone c++.

comunque:
invece della macro non bastava scrivere SOLO dentro l'if

if (R >= 250 && G < 20 && B < 5)) {...blablabla...

???

BALL(R(P),G(P),B(P)) è a sua volta una macro perchè definita

#define R(P) *(P)
#define G(P) *(P+1)
#define B(P) *(P+2)

quindi in realtà dovrei porre

if (*(P) >= 250 && *(P+1)< 20 && *(P+2) < 5)) {...blablabla...

[cionci]

Per la leggibilità a volte sono davvero utili

[sottovento]

Originariamente inviato da cionci

Per la leggibilità a volte sono davvero utili

Vero. Purtroppo spesso sono un'arma a doppio taglio, possono produrre effetti collaterali non indifferenti.

E poi, se ben usate, possono tornare utili per ottimizzare i tempi di esecuzione. Se usate male, invece, possono anche peggiorare le prestazioni.

In tutta sincerita', ho un sano terrore delle macro. Le uso con estrema cautela...

[vermaccio]

questo è un listato che m hanno dato da usare come "base" per capire come funziona un robot che, comandato tramite c++, trova una palla rossa tramite videocamera e ci si dirige.

guardate che intrico di macro: una che richiama l'altra....
se c'è un errorre non lo troverai mai!!!!!!
mi tocca riscriverlo in chiaro!!!!!!!

//esempio ricerca palla rossa

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <device/robot.h>
#include <device/differential_wheels.h>
#include <device/receiver.h>
#include <device/distance_sensor.h>

#include <device/camera.h>

#define MILLISECONDI 32

//Global variables
static int width, height;
unsigned char *image;
static int speed;
unsigned char *P;
static float f;
static DeviceTag camera;

//Define Colors
#define TRUE  1
#define FALSE 0
#define BALL(R, G, B)  (R >= 250 && G < 20 && B < 5)?TRUE:FALSE

//Image processing procedures
#define get_pixel(image, x, y) image+3*(x+y*width)
#define set_pixel(image, x, y, z) image[3*(x+y*width)] = z
#define R(P) *(P)    //puntatore a indirizzo P
#define G(P) *(P+1)  //puntatore a indirizzo P + 1 cella di puntatore: ovvero la cella dopo
#define B(P) *(P+2)  //puntatore a indirizzo P + 2 celle di puntatorio: ovvero due celle dopo






//XXXXXXXXXXXXXXXXXX
static void reset(void)
{
   camera = robot_get_device("camera");
   camera_enable(camera, MILLISECONDI);
   width = camera_get_width(camera);
   height = camera_get_height(camera);

//  printf("reset done\n");
}

static int run(int ms)
{
   short left_speed, right_speed;
   int i, j;

   image = (unsigned char *)camera_get_image(camera);

   left_speed = -20; //gira su se stesso finchè non trova la palla...
   right_speed = 20;

   //algoritmo ricerca palla
   for (j=0; j < height; j++) {
      for (i=width/2-5; i < width/2+5; i++) {
		  P = get_pixel(image, i, j);
          //ball
          if (BALL(R(P),G(P),B(P))) {
			  //printf("I see the red ball\n");
              left_speed = 50; //... ha trovato la palla e va verso la palla
		      right_speed = 50;
              goto next1; //break;
			  }
		  }
	   }


   next1: //finisci qui con il "goto"

   differential_wheels_set_speed(left_speed, right_speed);

   return MILLISECONDI;
}


//XXXXXXXXXXXXXXXXXX
int main()
{
   robot_live(reset);
   robot_run(run);
   return 0;
}

[cionci]

Non mi sembra che ci sia una grande confusione... Metti setPixel e getPixel come funzioni...

[vermaccio]

appunto!

quello è solo uno stralcio minimo del resto dei listati.
non hai idea del casino che c'è.

ci sono punti con una dozzina di define che si richiamano lìun l'altro e poi nel listato vengono infilati quà e là.

modificare il listato è impossibile.

scritto così è <<immodificabile>>

tocca estrapolare le functions!

che noia......

[sottovento]

Ciao,
se posso permettermi un consiglio, ti suggerei di eliminare il goto.
Invece di:

... omissis ...

static int run(int ms)
{
... omissis ...
   //algoritmo ricerca palla
   for (j=0; j < height; j++) {
      for (i=width/2-5; i < width/2+5; i++) {
		  P = get_pixel(image, i, j);
          //ball
          if (BALL(R(P),G(P),B(P))) {
			  //printf("I see the red ball\n");
              left_speed = 50; //... ha trovato la palla e va verso la palla
		      right_speed = 50;
              goto next1; //break;
			  }
		  }
	   }


   next1: //finisci qui con il "goto"

... omissis...

puoi fare:

... omissis ...

static int run(int ms)
{
   BOOL found = FALSE;

... omissis ...
   //algoritmo ricerca palla
   for (j=0; j < height && !found; j++) {
      for (i=width/2-5; (i < width/2+5) && !found; i++) {
		  P = get_pixel(image, i, j);
          //ball
          if ((found = BALL(R(P),G(P),B(P)))) {
			  //printf("I see the red ball\n");
              left_speed = 50; //... ha trovato la palla e va verso la palla
		      right_speed = 50;
              
               //break;
			  }
		  }
	   }


// Al termine del ciclo, il flusso di esecuzione sara' qui.
// Se found == FALSE non hai trovato la passa, altrimenti l'hai trovata


... omissis...

C'e' anche un altro problemino nel codice originale: al termine del ciclo non hai informazioni sul fatto che la palla sia stata trovata o meno (a meno di non controllare se la speed e' cambiata).

Infine una curiosita': il codice si basa sul fatto di aver trovato un solo punto rosso al centro dell'immagine. Non e' poco per stabilire di aver trovato la palla?

Scusa se sono stato un po' invadente

High Flying
Sottovento

[vermaccio]

Originariamente inviato da sottovento

C'e' anche un altro problemino nel codice originale: al termine del ciclo non hai informazioni sul fatto che la palla sia stata trovata o meno (a meno di non controllare se la speed e' cambiata).

questa non l'ho capita. intendi dire che se non trova la palla (es: la palla non esiste proprio come caso limite) lui continua all'infinito a girare senza fermarsi MAI?

Originariamente inviato da sottovento

Infine una curiosita': il codice si basa sul fatto di aver trovato un solo punto rosso al centro dell'immagine. Non e' poco per stabilire di aver trovato la palla?

perchè al centro dell'immagine? non esce dal ciclo if appena vede un punto rosso anche al bordo immagine?

Originariamente inviato da sottovento

Scusa se sono stato un po' invadente
High Flying
Sottovento

ma che invadente! ben venga! sto smadonnando su questo listato scritto da un cane!!!! ha bug ovunque!

[sottovento]

Originariamente inviato da vermaccio

questa non l'ho capita. intendi dire che se non trova la palla (es: la palla non esiste proprio come caso limite) lui continua all'infinito a girare senza fermarsi MAI?

Se non trova la palla, i due cicli for innestati verranno completati e l'esecuzione passera' al codice che segue l'etichetta del goto.
Verra' pertanto effettuata la
differential_wheels_set_speed(left_speed, right_speed);
con i valori (non cambiati) di left_speed e right_speed.
Non so dirti di piu': ti posso solo dire che, differenza di speed a parte, da quel punto in poi l'esecuzione non terra' conto del fatto che la palla sia stata trovata o meno.

Originariamente inviato da vermaccio

perchè al centro dell'immagine? non esce dal ciclo if appena vede un punto rosso anche al bordo immagine?

Il secondo ciclo e':

for (i=width/2-5; i < width/2+5; i++)
....

dove width sembra inizializzato alla dimensione dell'immagine presa dalla camera.
Il ciclo esterno, invece, va da 0 a height (sarebbe height -1 ma non ha importanza).
Pertanto il tuo robot analizza una striscia verticale di 10 pixel al centro dell'immagine raccolta.

Ripeto ancora la mia perplessita': un solo pixel non e' troppo poco? Probabilmente l'ambiente in cui il robot e' messo sara' stato attrezzato per facilitare il compito, cmq mi sembra un po' rischioso... non dico di implementare degli algoritmi di pattern matching (anche se sarei pronto a scommettere che li trovi gia' pronti su Internet), pero' magari sarebbe opportuno verificare che ci sia un gruppo di pixel adiacenti, che siano rossi...

Originariamente inviato da vermaccio

ma che invadente! ben venga! sto smadonnando su questo listato scritto da un cane!!!! ha bug ovunque!

Beh, cerca di vedere i lati positivi. Mettere le mani nel codice altrui non e' mai facile, ma ti permette di imparare tantissimo, dagli errori e dalle soluzioni trovate (che spesso sono geniali).

E poi... un giorno qualcuno mettera' mano al tuo codice, no?

High Flying
Sottovento

[vermaccio]

Originariamente inviato da sottovento

non dico di implementare degli algoritmi di pattern matching (anche se sarei pronto a scommettere che li trovi gia' pronti su Internet),

cosa sono? e dove li trovo?

Originariamente inviato da sottovento

pero' magari sarebbe opportuno verificare che ci sia un gruppo di pixel adiacenti, che siano rossi...

come potrei fare per adottare questa soluzione? una volta trovato un puntino analizzo se attono che ne sono altri facendo un "cerchio" di pixel attorno al pixel trovato?

[sottovento]

Originariamente inviato da vermaccio

cosa sono? e dove li trovo?

Probabilmente su Internet trovi qualcosa. Sono passati parecchi anni dalla laurea, e molti di piu' dall'esame di elaborazione delle immagini, per cui non mi ricordo tantissimo.
Devo avere ancora i libri, cerco i titoli (mi ricordo un "digital image processing", forse qualcuno nel forum ha informazioni piu' aggiornate).
Comunque se cerchi qualcosa tipo "image analysis pattern matching" dovresti trovare un bel po' di roba, probabilmente gia' pronta per l'uso.

Originariamente inviato da vermaccio

come potrei fare per adottare questa soluzione? una volta trovato un puntino analizzo se attono che ne sono altri facendo un "cerchio" di pixel attorno al pixel trovato?

Puoi cercare di implementare un algoritmo piuttosto famoso, basato sulle adiacenze. Una volta applicato questo algoritmo (che e' abbastanza veloce per una scansione on line), puoi calcolare facilmente l'area degli oggetti in esame (espressa in pixel) e prendere opportuni provvedimenti.

Innanzitutto: puoi vedere la tua immagine come se fosse binaria: la tua macro BALL() te la "binarizza", nel senso che un pixel rispetta la condizione, oppure no.
Questa condizione e' importante per questo passaggio.

Mi e' capitato di dover implementare questo algoritmo, per cui ne conosco i dettagli. La spiegazione e' semplice ma un po' lunga, per cui non posso fornirtela ora.
Fai prima una ricerca su Internet, se non trovi nulla, allora posto l'algoritmo (magari stasera)

High Flying
Sottovento

[sottovento]

Ciao,
hai trovato qualcosa che fa al caso tuo?

Ad ogni modo, l'algoritmo piu' facile e' questo:
- Abbiamo gia' premesso che l'immagine e' praticamente "binaria" (ho sufficiente rosso oppure no).

Ora possiamo provare ad estrarre degli oggetti (la palla):

inizializza "count" a 1; (non 0, mi raccomando)

1 - prepariamo una nuova immagine/matrice che conterra' gli oggetti che vuoi estrarre. Questa matrice e' inizializzata a tutti zero;

2 - scandisci l'immagine di partenza da sx a dx, dall'alto in basso (due cicli for annidati);
3 - per ogni punto:
3.1 - se BALL() e' FALSE, allora non fai alcuna operazione (nella nuova matrice rimane il punto di tali coordinate a zero);
3.2 - se BALL() e' TRUE, allora controlla il punto immediatamente a sinistra e sopra (se esistono. Se non esistono, e' come se fosse zero).
3.2.1 - Se i punti controllati sono entrambi a zero, allora nella nuova matrice, nella posizione di tale pixel, ci metti il valore di "count". Incrementi poi "count";
3.2.2 - Se uno dei punti controllati ha valore diverso da zero, allora puoi copiare detto valore anche per questo pixel.
3.2.3 - Se entrambi hanno valore diverso da zero, puoi scegliere quale valore copiare. Dovrai pero' salvare in una struttura a parte (una lista) entrambi i valori (tradotto in italiano significa: mi rendo conto che i due valori rappresentano lo stesso oggetto. Potremmo parlare di relazione di equivalenza, in cui il numero e' rappresentante della classe di equivalenza stessa).

Una volta finita questa scansione, avrai una nuova matrice dove, nelle aree potenzialmente interessate dalla presenza di un oggetto rosso, si accumulano delle caselle con dei numeri.

L'ultima passata la fai su questa nuova matrice, scegliendo un numero dalla tua relazione di equivalenza (l'hai creata con la lista): se, per esempio hai stabilito che le caselle marcate con "1" e quelle marcate con "10" sono equivalenti, farai la sostituzione, per esempio, di tutte le caselle "10" col valore "1".
Questo ti permette di individuare, per esempio, anche gli oggetti concavi: per esempio, una "U", scandendo da sx a dx e dall'alto verso il basso, avrebbe numeri diversi per la prima e la seconda asta. Quando arrivi a "chiudere" la figura, ti accorgeresti dell'equivalenza. Con la sostituzione, hai che tutti i punti della "U" hanno un numero solo.

E cosi'...hai un'immagine in cui tutti gli oggetti sono distinti, ed ognuno e' individuato mediante un unico numero.
Puoi farci ora tante belle operazioni: puoi, per esempio, calcolare l'area dell'oggetto "3" (ti basta contare quanti 3 ci sono, sono tutti adiacenti), puoi applicare algoritmi piu' sofisticati, ....

Nel tuo caso, controllerei semplicemente l'area ed eliminerei dalla mia attenzione tutti gli oggetti troppo piccoli.

Se ho tempo, ti codifico tutta questa cosa in C (purtroppo non ho tanto tempo, sono in partenza per una trasferta molto lunga...).

Spero di esserti stato utile

High Flying
Sottovento

[vermaccio]

ti ringrazio per le iddee.
oira per due settimane devo leggere io manualissimo di openCV
http://www.intel.com/technology/comp...v/overview.htm

appena fatto e passo alla parte applicativa magari ci risentiamo se ho problemi

comunque se hai algoritmi in c++ già fatti...manda pure. se vuoi ti do la mia mail.

ciao

[sottovento]

Originariamente inviato da vermaccio

comunque se hai algoritmi in c++ già fatti...manda pure. se vuoi ti do la mia mail.

ciao

Appena ho un attimo, controllo nel mio "archivio". Se trovo qualcosa di tuo interesse mi faccio sicuramente vivo

High Flying
Sottovento

[sottovento]

Originariamente inviato da vermaccio

ti ringrazio per le iddee.
oira per due settimane devo leggere io manualissimo di openCV
http://www.intel.com/technology/comp...v/overview.htm

ciao

Sono andato a vedere il sito. E' proprio interessante e fa al caso tuo.
Direi che l'algoritmo che ti ho presentato e' sicuramente implementato in quella libreria.

Buon lavoro
Sottovento

[vermaccio]

la settimana prossima mi inizio a leggere quel mattone del reference manual. povero me!


ma senza quella libreria sarei invecchiato a scrivere le funzioni. sarebbe stato disumano.

comunque se trovi qualcosa di tuo mandamelo.


ciao

[vermaccio]

ho trovato in rete un listato cpp che dovrebe effettuare il calcolo del determinante di una matrice!!!!!

domanda: l'intestazione della functiion dice
double Det(double **mtrx, int dim);

e che è "**"? *è puntatore. ma **?


eccoti allegato il listato se ti interessa.
io ancora non l'ho compilato e testato anche perchè ancora non ho capito la matrice di ingresso, visto il "**", che forma deve avere.

[shinya]

Originariamente inviato da vermaccio

ho trovato in rete un listato cpp che dovrebe effettuare il calcolo del determinante di una matrice!!!!!

domanda: l'intestazione della functiion dice
double Det(double **mtrx, int dim);

e che è "**"? *è puntatore. ma **?


eccoti allegato il listato se ti interessa.
io ancora non l'ho compilato e testato anche perchè ancora non ho capito la matrice di ingresso, visto il "**", che forma deve avere.

Ti conviene tenere accanto anche un manuale del linguaggio.
Se * è "puntatore", ** è "puntatore a puntatore". La firma della funzione ti dice di passare un puntatore a puntatore di double e la dimensione. Di dimensione ce n'è una sola perchè suppongo la funzione si applichi a matrici NxN. I puntatori a puntatori sono il modo tipico di rappresentare matrici di valori in C (e volendo anche in C++, anche se...). Per darti un'idea:

double **malloc2d(int n, int m) {
  int i;
  double **t = malloc(n * sizeof(double*));
  for (i = 0; i < n; ++i)
    t[i] = malloc(m * sizeof(double));  
  return t;
}