Traduire un unsigned short* en image Qt

Bonjour,

Je reçois une séquence d'images de taille fixe (320 par 240) sous forme d'unsigned short* (vector<unsigned short> en réalité mais bon).

Je cherche via QImage à pouvoir afficher les images les unes après les autres... mais je ne vois pas trop comment lui faire comprendre ce que je veux.

(oui, l'image est en niveaux de gris)

Quelqu'un aurait-il un indice ?

(je risque d'afficher l'image résultante dans un QLabel qui sera lui mis dans un QGraphicsView probablement)

:merci:

Tu peux pas faire une règle de trois en partant du principe que 255 = 65535 ?

Si le débit n'est pas trop important, tu peux utiliser utiliser un QImage en accédant directement aux pixels via un scanLine. Comme la taille est connue, c'est assez simple :

A l'initialisation :

Code:

---

1 2 3 4 5 6 7 8

// Creation de l'image QImage m_img(320, 240, QImage::Format_Indexed8); // Table de couleur QVector<QRgb> m_colors; for(int i = 0; i < 255; i++) m_colors.append(qRgb(i, i, i)); m_img.setColorTable(m_colors);

---

A chaque nouvelle image :

Code:

---

1 2 3 4 5 6 7 8 9

for(int y = 0; y < 240; y++) { uchar *scanL = m_img.scanLine(y); for(int x = 0; x < 320; x++) { *scanL++ = data[(y * 320) + x]; } }

---

C'est de mémoire, mais en gros ça serait une idée...

Si le débit est trop rapide, Qt n'arrivera pas à suivre.
Une solution mixant SDL et Qt sera excellente. Et si besoin de traitement d'image à la volée, le trio gagnant : OpenCv + SDL + Qt.

Citation:

---

Envoyé par superjaja

Tu peux pas faire une règle de trois en partant du principe que 255 = 65535 ?

---

Ca marche plutôt bien en général.

Pas mieux que LeGars.

Par contre je voie pas l'intérêt d'utiliser OpenCV ou sdl ici.

Transformer une image 16 bits en image visible c'est rien du tout. Surtout, vue la taille de l'image ca va pas prendre de temps. A choisir entre une image indexé sur 8 bits ou directement une image RGB. Pour transformer ton pixel 16bits en RGB, tu peut utiliser un qlineargradientl. Ça interpolera directement les couleurs. Ça marche bien


Au lieux de mettre un QLabel dans un QGraphicsWidget, utilise un
qgraphicspixmapitem

Citation:

---

Envoyé par yan

Par contre je voie pas l'intérêt d'utiliser OpenCV ou sdl ici.

---

C'est une question de débit. J'ai bossé sur un projet ou le rafraichissement était relativement rapide (env 150/s) avec des images de tailles moyennes (1024x512) et l'affichage via Qt ralentissait tout.
D'où l'utilisation via SDL puis OpenCv pour le détourage automatique...
C'est juste au cas où :)

Bah en fait, l'idée c'est quand même d'être assez rapide si possible car ce que j'écris pourrait à terme être utilisé en temps réel.

Pour la règle de trois hmm ça me gêne un peu. Je lui filerais donc un unsigned char* au final ? On y perd.

Mon seul soucis, c'est actuellement de trouver "la bonne classe (C) (TM)" qui prendrait mon unsigned short*. Bref, c'est vraiment de trouver l'endroit par lequel je peux introduire mes données images brutes de chez brutes dans Qt.

Par contre, je ne vois pas trop pour QLinearGradient, tu pourrais donner un exemple ? Elle n'a pas l'air faite pour ça (ou alors j'ai trop lu en diagonale :aie:).

Sinon, LeGars, ta solution marcherait mais c'est je pense un poil trop lent, j'essayerai de bencher ça ASAP. Un traitement bas niveau sans modifier la QImage pour ensuite faire le boulot, ça serait bien.

Bref, n'hésitez pas à illustrer ou donner des exemples, ça m'aiderait pas mal.

PS : on utilise Vigra :mrgreen:

[QUOTE=Alp;4469242]Par contre, je ne vois pas trop pour QLinearGradient, tu pourrais donner un exemple ? Elle n'a pas l'air faite pour ça (ou alors j'ai trop lu en diagonale :aie:)./QUOTE]

Je suis allez un peu vite (je me rappelais plus trop ce que j'avais fait :aie:)

i

Code:

---

1 2 3 4 5 6 7 8 9 10 11

nt maxValue =65535; QLinearGradient lgrad(0,0,maxValue ,0); lgrad.setStops(m_stops);   QImage LUT(maxValue ,1,QImage::Format_ARGB32); { QPainter p(&LUT); p.setBrush(lgrad); p.setPen(Qt::NoPen); p.drawRect(LUT.rect()); }

---

et tu as une jolie LUT pour convertir tes unsigned short en couleur RGBA :D
Je n'ai rien en Qt qui permet de gérer nativement du monochrome 16 bits

Citation:

---

Envoyé par yan

et tu as une jolie LUT pour convertir tes unsigned short en couleur RGBA :D
Je n'ai rien en Qt qui permet de gérer nativement du monochrome 16 bits

---

Hmm... Je vois, mais m_stops serait quoi dans ce cas ?

Enfin bref je vois pas trop comment ça aide :aie:

Citation:

---

Pour la règle de trois hmm ça me gêne un peu

---

Elle est surtout nécessaire avec Qt qui ne prend pas vraiment en charge le format 16bit en niveau de gris. Problème qui disparait avec SDL ou OpenCv.

Citation:

---

c'est je pense un poil trop lent

---

A partir du moment ou Qt doit faire l'affichage, effectivement, il ne faut pas être sur les starting-block.

Une première solution qui nous a fait gagné en perf c'est le fait d'inclure SDL dans une fenêtre Qt. L'image est créée et gérée par SDL. Quelques explications s'imposent...

Tout d'abord une surcharge d'un QWidget avec implémentation de la méthode showEvent(QShowEvent *e)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

void QMySDL::showEvent(QShowEvent *e) { Q_UNUSED(e);   if (!windowInitialized) { // C'est ici qu'on donne la main à SDL sur le dessin du Widget char windowid[64]; sprintf(windowid, "SDL_WINDOWID=0x%lx", reinterpret_cast<qlonglong> (winId())); SDL_putenv(windowid);   // Initialisation du système vidéo de SDL SDL_Init(SDL_INIT_VIDEO);   // Initialisation de la surface écran m_screen = SDL_SetVideoMode(width(), height(), 32, SDL_HWSURFACE | SDL_RESIZABLE);   windowInitialized = true; } }

---

Puis à chaque nouvelle image :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

void QMySDL::drawImage(unsigned short *data) { // Donnée -> Sdl SDL_Surface *surface = SDL_CreateRGBSurfaceFrom( (void*)data, 320, 240, 16, 16 * 320, 0, 0, 0, 0);   // MAJ SDL_BlitSurface(surface, NULL, m_screen, NULL); SDL_UpdateRect(m_screen, 0, 0, 0, 0); SDL_FreeSurface(surface); }

---

Le fichier entête qui correspond (en gros):

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

class QMySDL : public QWidget { Q_OBJECT   public: ~QMySDL() { SDL_FreeSurface(m_screen); SDL_Quit(); }   protected: void showEvent(QShowEvent *e); void drawImage(unsigned short *data);   SDL_Surface *m_screen; bool windowInitialized; };

---

Citation:

---

Envoyé par Alp

Hmm... Je vois, mais m_stops serait quoi dans ce cas ?

---

c'est une list avec une pair nombre <-> une couleur. Y as un exemple ici
http://qt.developpez.com/faq/?page=q...parence-widget.
En gros, ca te permet d'interpoler correctement une LUT avec quelques point de couleurs et ainsi transformer facilement ta valeur 16 bits en RGB.

Pour SDL, qu'es ce qu'il fait pour afficher l'image? A mon avis à peu prés la même chose que la règle de trois ou l'utilisation d'une LUT.

A titre "anecdotique", j'ai finalement réussi ce que je voulais faire avec vigra+vigraQt+Qt assez facilement.

VigraQt permet de récupérer des images Vigra et de transformer en QImage, via les QRGBImage, etc.

Un petit bout de code c'est joubale ?
Oui je sais je suis gourmand Alp. :D

Biensûr.

Ca donne quelque chose de ce goût-là :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// vec est un vector<unsigned short> qui décrit l'image donc vigra::UInt16Image image(320,240, &vec[0]);   if(autorescale) { // lut est ma look-up table lut.setMin(*std::min_element(vec.begin(), vec.end())); lut.setMax(*std::max_element(vec.begin(), vec.end())); }   vigra::QRGBImage img(320, 240);   std::transform(image.begin(), image.end(), img.begin(), RGBisator(lut));   v.setImage(img.qImage());

---