Discussion :

[Captain Moule]

Bonjour à tous,

Je suis sur un projet un peu particulier et c'est ces particularités qui me font vous écrire aujourd'hui :

Un appareil d'observation astronomique équipé d'une tête d'observation avec tout un système optique ramène les photons incidents vers une matrice de capteurs photosensibles ( 8lignes * 8colonnes = 64 capteurs). Et ces capteurs me rendent la valeurs à l'instant t. t étant l'instant où 1 des 64 capteurs capture un "événement", c'est à dire qu'un seuil a été dépasser sur au moins un capteur et donc on enregistre toute l'image que réalise notre matrice.

C'est la version ultra courte et j'espère que vous comprenez jusque là, de notre côté à nous informaticiens, on récupère un string avec 64 valeurs (souvent comprise entre 800 et 1500, pouvant aller jusqu'à 3000) séparées par des espaces. Premier détail, il peut y avoir un événement toutes les 20 nano secondes. C'est assez court. Et donc un tel string est créer au pire toutes les 20 ns. (64*4char + 63char = 319 caractères max)

Bref, je dois mettre sur l'écran de cet appareil, un rendu temps réel de ce qu'on observe. Mais également, faire un vrai programme tout autour, avec la barre de menu [Fichier][Edition][Affichage]... et une barre fixe en bas pour savoir le statut de la tête d'observation. Dans fichier, on peut créer un nouveau projet qui, quand on le lance, enregistre tous les événements pendant une durée déterminée par l'utilisateur. Jusque là, rien de bien sorcier me direz-vous.

Alors je suis parti sur du Windows Form en C#, faisant une interface permanente et en faisant en sorte qu'au centre de cette interface puisse s'inter-changer les "pages" comme sur Visual Studio. Une page d'accueil, quand on charge ou créer un projet, etc.

Et là on rentre dans le vrai problème. Vu que notre fréquence de modification des valeurs peut être toutes les 20 ns, il va falloir que je fasse en sorte que tout ce beau monde se synchronise au rendu dynamique qui doit juste représenter la valeur à un instant donné et PAS montrer à chaque frame, l’événement suivant de la matrice, car elle en a sûrement détecter plusieurs.

Si je ne suis pas clair ici, dites vous que je souligne le problème suivant : entre ma matrice qui va envoyer plusieurs image (par exemple on a eu 6 événements en 0.010s alors que l'écran lui ne s'actualise que toutes les 0.017s (et si il y a du lagg?). Il faut donc que je m'assure que tout est synchro (dans notre exemple il faudrait simplement afficher le 6ème événement).
Vous comprenez bien qu'on risque rapidement d'être submergé d'informations, il faut donc en plus que je rende ce rendu suffisamment light. Je suis donc parti sur du windows form et j'ai créer une "visionneuse" (un panel) dans lequel je mets un tableLayoutPanel et dedans, je mets 64 label qui se voient modifier leur valeur à chaque événement et je change également la couleur de fond du lanel de noir à blanc (noir = minimum, blanc = maximum) en passant par tous les dégradés de gris en fonction de la valeur. J'ai d'ailleurs un problème pour faire comprendre à mon tableLayoutPanel qu'il ne doit y avoir que 8 objets par ligne, en l'état il les affiche tous les un à la suite des autres et ça ne représente pas du tout ma matrice de 8x8.

Question : est-ce efficient? Je me doute que non, mais je pourrais passer par des panel ça reviendrait au même... Autre chose, je suis très médiocre en graphique, j'adore la programmation, mais je m'occupe rarement de faire les fenêtres et boutons.

Dans l'idée, je suppose qu'il faut que je créer véritablement l'objet visionneuse capable de se redimensionner automatiquement en affichant systématiquement les 64 cases. Mais je n'ai aucune idée de comment faire une telle chose, de quoi mon objet doit hérité? Et donc comment le synchroniser également?

Je vais arrêter là pour les explications de mon projet, sachant que je suis bien perdu, ça ne doit pas être simple de savoir comment m'aider pour vous . Je suis dispo pour la moindre question ou idée.

Bien à vous amis programmeurs.

[Captain Moule]

Up !

Bon mon explication n'a convaincu personne, je le comprends, donc voici quelques images car j'ai fini ma visionneuse en utilisant des labels :


Voici donc mon programme en mode lecture d'un projet et la visionneuse est à droite et représente un évenement.

Quand je clique sur le bouton "Play a step", la visionneuse s'actualise tout simplement à l’événement suivant :



En gros ça marche, mais déjà ce n'est pas efficient, comme je le supposais, on sent une certaine lenteur dans le changement de mes 64 cases.
De plus j'aimerais, en cliquant sur le bouton "Play", que ma visionneuse enchaine les évenements toute seule sans intervention, seulement ma fonction, c'est ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
        private void buttonPlay_Click(object sender, EventArgs e)
        {
            buttonRepeat.Enabled = true;
            buttonPause.Enabled = true;
            while (currentProject.FPGA.matrice.Count() > 0)
            {
                currentProject.FPGA.Remplissage(loader);
                UpdateTab();
            }
        }

Deux choses, je ne peux rien faire pendant qu'il est dans cette boucle (il va falloir que je passe par un thread, mais je ne sais pas trop comment m'y prendre), de plus, le calcul s’enchaîne tellement vite que rien ne change sur la visionneuse avant le dernier événement, c'est à dire, quand le vidéo du projet se termine. Comment je force mes labels à s'actualisé à chaque itération ? Parce que dans ma méthode "Play a step", j'utilise les mêmes fonctions Remplissage(Loader) et UpdateTab() qui marchent !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
        private void buttonStepByStep_Click(object sender, EventArgs e)        {
            buttonRepeat.Enabled = true;
 
 
            currentProject.FPGA.Remplissage(loader);
            UpdateTab();
        }

Dernière précision, je change la valeur "text" de chaque label avec la valeur de mon capteur et c'est l’événement "TextChanged" qui quand il se trigger, change la couleur du label.BackColor pour représenter l'intensité lumineuse.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
        private void labelVisu0_TextChanged(object sender, EventArgs e)        {
            Label lbl = sender as Label;
            string test = lbl.Name.Split('u').Last(); // Je recupère juste le numéro de ma case
 
 
            lbl.BackColor = currentProject.FPGA.matrice[int.Parse(test)].colorLG; //Et donc je change la couleur de fond du label
 
 
        }

Tout ça se passant donc dans un UserControl.

Des idées please ?

[ClaytonG]

Dans ton projet si j'ai bien compris tes 64 label on la valeur de tes 64 capteur ? Si oui ça veut dire que tu veut les actualiser toute les 2x10E-8s ? Si j'ai "compris" ton projet tes labels sont complètement illisible non ?

[Captain Moule]

Alors oui, non et oui et non, ici je ne suis pas face à une vraie analyse, j'en lis une que j'ai fabriqué de toute pièce. En gros le programme (une fois fini) devrait pouvoir faire deux choses principales : créer une analyse (un projet) ET la revisionner (on ouvre un projet déjà existant pour l'analyser avec différents outils, image par image, moyenne, cumul des valeurs, etc...). Pour m’entraîner à faire une visionneuse efficace, j'ai donc fais le choix de commencer par le revisionnage. J'ai donc créer un fichier contenant 100 événements consécutifs pour pouvoir passer la première étape qui créer le fichier.

Bref, ça me semblait important de préciser ça avant que je ne réponde à tes questions en détail :

Dans ton projet si j'ai bien compris tes 64 label on la valeur de tes 64 capteur ?

Effectivement, chaque capteur me renvoie une valeur entre 0 et 40 000 (à peu de choses près) que je récupère sous la forme d'un string brut. Dans la pratique, la simple température du système et le champ électromagnétique ambiant fait qu'un bruit constant fait qu'on n'a jamais de valeur en dessous de 850. Et vu que l'on fait de l'observation au photon près, on regarde des zones peu lumineuse (c'est le but en fait, voir ce qui émet que dalle ! ) et donc si on trouve fréquemment des valeurs supérieures à 3000, c'est qu'on utilise pas le bon matériel. Donc dans la pratique, j'ai 64 valeurs comprises entre 850 et 3000 dont 95% sont entre 900 et 1200 qui correspondent à l'aflux de photon de CHAQUE capteur.

Si oui ça veut dire que tu veut les actualiser toute les 2x10E-8s ?

Pour l'actualisation toutes les 20 nano secondes, déjà c'est une problématique de quand on CREER un projet et non pas quand on le revisionne (attention à ça, c'est la même visionneuse en apparence, mais ça n'est pas les même problématique), puisque dans ce cas, on choisi la vitesse que l'on veut, mais donc non, je ne veux pas rafraîchir l'écran aussi vite (ça n'est pas possible de toute façon), justement, j'aimerais pouvoir être sûr que quand ma visionneuse affiche sa frame suivante, ça soit la représentation du dernier événement en date.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Frame visionneuse : |            |            |            |            |            |     (ici on représente une frame de 60hz par un | )
Événements :        |  || |  || |  || |||| |   |     ||  ||| ||||||   |  |||    | || |     (Chaque | est un événement, les | sont ceux affiché)
Sens du temps       ================>

Attention, on sauvegarde tout mais lors de la création du fichier, pour que l'utilisateur puisse voir si il y a un problème, on met un rendu temps réel, comme un stream. Sauf qu'ici la camera m'envoie plus d'images que je ne peux en montrer, donc il faut que je garde le temps réel en occultant certain événement.

Si j'ai "compris" ton projet tes labels sont complètement illisible non ?

Et pour ta dernière question, je ne sais pas ce qu'il se passe exactement, mais pendant mon play supposé tout lire, ce que j'observe c'est : rien. L'écran ne change pas d'un pouce jusqu'à la fin, je peux être à mon événement numéro 10 sur 100, je clique sur play et je vais garder l'événement 10 à l'écran pendant que l'ordi traite les 90 suivants et ça je le vois car je lui ai demandé de me raconter le beau temps dans la console histoire d'être bien sûr d'au moins rentrer dans la fonction updateTab(). J'ai l'impression que le problème vient des labels et windows form...

[Pol63]

pas compris tous les problèmes

mais il faudrait que tu utilises des timer je pense
au mieux tu peux le paramétrer à 16ms (mais il fera parfois au dessus, il n'est pas super précis)
pour le mode temps réel ca va te permettre toutes les 16ms de récupérer la dernière trame reçue et de l'afficher (donc environ 60 "images" seconde)

pour le mode play, là aussi le timer pourra t'éviter de faire une boucle, il faudra juste stocker dans une variable à quelle frame tu es et l'incrémenter (dans le timer.tick ou autre) pour que sur le tick tu affiches là où ca en est dans la lecture

si l'interface est lente à répondre il y a peut etre quelques optimisations à faire, si ca ne suffit pas il faudrait passer sur wpf (qui est plus efficace graphiquement que windows forms)
mais je ne vois pas en quoi des choses qui ne bougent pas (autre que texte et couleur) ca pourrait ramer en windows forms (c'est surtout changer location et size qui peuvent faire ramer)