spoke

spoke est une bibliothèque de composants javabeans pour le traitement du signal. Elle a été développée en utilisant le bdk de Sun et sa beanbox, mais en principe elle devrait marcher avec n'importe quel autre environnement de developpement javabeans. Les composants peuvent également être incorporés à des applications développées en mode texte, comme tout composant javabeans.

Idée générale

L'idée est d'implémenter des modules de traitement du signal, commme la transformée de Fourier, sous forme de composants javabeans, afin de pouvoir profiter des techniques de développement rapide pour la conception et le test de chaines de traitement du signal.

A cet effet a été mis en place un nouveau type d'évènement javabeans, la "connexion". Cet évenement est envoyé en premier par un module maitre au(x) module(s) suivant(s), et ainsi de suite de proche en proche dans toute la chaine.

A la reception d'un évènement "connexion", un module démarre un nouveau thread qui lit des entrées sur un tube (PipedInputStream), effectue un traitement, et écrit les données résultantes sur un tube de sortie (PipedOutputStream).

Modules

Il y a trois types des modules: Certains modules sont associés à des object graphiques, en particulier les sources de données (qui seront typiquement des boutons que l'on pourra cliquer pour démarrer le traitement), et les modules de sortie destinés à afficher les résultats. Les autres modules peuvent être manipulés dans l'environnement de développement graphique, mais n'apparaitront pas dans l'application finale.

Développement d'un module

Tout le travail consiste à implementer la méthode "run" héritée de l'interface Runnable par la classe Module dont descendront tous nos composants. Par exemple pour la transformée de Fourier, cela donne:

        public void run() {
                ComplexInput in=(ComplexInput)connector.getInputStream(0);
                ComplexOutput out=(ComplexOutput)connector.getOutputStream(0);

                stopped=false;
                while(!stopped) {
                        try {
                                for(int i=0;i<buffer.length;i++)
buffer[i]=in.readComplex();
                                if(sens) {
                                        tfr.compute(buffer,true);
                                        if(hamming) for(int
i=0;i<buffer.length;i++) buffer[i]=(Complex)buffer[i].divide(fenetre[i]);
                                } else {
                                        if(hamming) for(int
i=0;i<buffer.length;i++) buffer[i]=(Complex)buffer[i].multiply(fenetre[i]);
                                        tfr.compute(buffer,false);
                                }
                                for(int i=0;i<buffer.length;i++)
out.writeComplex(buffer[i]);
                        } catch (InterruptedIOException e) {
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                }
        }

On voit qu'il y a simplement lecture, traitement, ecriture. Les différents paramètres utilisés par l'algorithme sont manipulés grâce aux methodes "set" et "get" de l'architecture javabeans, c'est-à-dire graphiquement. Les modules sont donc pensés comme des "enveloppes" pour des algorithmes de traitement du signal, permettant de régler leurs paramètres et de les faire fonctionner de manière simple.

Construction d'un synoptique

On peut poser par exemple un "Generator" et un "Oscilloscope", et définir le second comme "ConnectionListener" du premier. Pour cela, séléctionner le "Generator", faire Edit->Events->connection->connection de la barre de menu, cliquer sur le composant cible "Oscilloscope", choisir "connection" comme méthode cible, et cliquer sur ok.
Ensuite, on peut ajuster les paramètres de nos composants, par exemple:

Generator:
frequence = 0.0625
longueur = 128

Oscilloscope:
largeur = 128

Test de la chaine

Presser le bouton du Generator : une sinusoide apparait sur l'Oscilloscope.
Presser une seconde fois pour stopper les threads de tout les composants de la chaine (en effet le Generator s'arrête au bout de 128 echantillons, mais l'Oscilloscope continue à attendre des données si on ne l'arrête pas).

Sauvegarde

Pour sauvegarder le synoptique, faire File->Save... <nom du fichier>.
L'exemple exposé ici est repris dans le fichier sinusoide.jar se trouvant dans le répertoire "projects".

On peut également sauvegarder des composants individuels avec leurs paramètres, en faisant File->SerializeComponent. On fait ensuite entrer un composant sérialisé dans la palette en en faisant un fichier .jar, par la procédure javabeans habituelle.

Cette sauvegarde individuelle est intéressante en particulier pour les composants à apprentissage, comme les réseaux de neurones, car elle permet de conserver le résultat d'un apprentissage et de tests faits avec notre synoptique, pour une utilisation indépendante. On peut par exemple envoyer le réseau de neurones par mail à un collègue, ou bien l'incorporer dans une application indépendante...

Liste des modules

audio/AudioResource

module source pour la lecture de fichier au format .au de Sun

audio/Speaker

module de sortie vers la carte son

audio/Microphone

module source d'entrée de la carte son

chaos/LorenzBean

module source donnant une coordonnée d'un point de l'attracteur de Lorenz

fourier/Recouvrement

module de traitement effectuant un recouvrement pour traitement ultérieur par t.f.r.

fourier/Fourier

module de traitement calculant une transformée de Fourier rapide

fourier/Fourier2

pareil que précédement, avec seulement la première moitié de la gamme de fréquence symétrique

fourier/SignalAnalytique

module de traitement tansformant un signal réel en signal complexe

image/ImageResource

module source de lecture de fichiers graphiques

kohonen/SelfOrganizingMap

module de traitement implémentant un réseau de neurone de Kohonen

kohonen/LearningVectorQuantization

module de traitement implémentant un algorithme de quantification vectorielle de Kohonen

misc/Dirac

module source de production d'une impulsion

misc/Modulateur

module de traitement pour la modulation en amplitude et en phase

misc/Integrateur

module de traitement de filtrage intégrateur/dérivateur ; à associer avec le Modulateur pour réaliser une modulation de fréquence

misc/Bruit

module source de production d'un signal aléatoire gaussien

ondelette/Ondelette

module de traitement calculant une transformée en ondelettes rapide

ondelette/Resume

module de traitement de réduction du nombre de points au moyen de la t.o.r.

ondelette/Ondelette2D

module de traitement calculant une t.o.r. 2D

ondelette/Resume2D

module de traitement de réduction du nombre de points 2D

ondelette/AlgorithmeATrous

module de traitement produisant un diagramme d'ondelettes

parole/Preaccentuation

module de traitement de filtrage passe-haut

util/Generator

module source produisant différentes formes d'onde

util/Logarithme

module de traitement calculant le logarithme du module et la phase du signal complexe d'entrée

util/Oscilloscope

module de sortie pour la visualisation d'un signal

util/Diagramme

module de sortie pour la visualisation d'un diagramme

util/Additionneur

module de traitement qui additionne n entrée pour produire 1 sortie

util/Repeteur

module de traitement qui produit n sorties identiques à 1 entrée

Liste des composants classiques

util/Curseur

scrollbar avec une propriété "commande" pouvant être liée aux paramètres des modules grâce au mécanisme de "bound property"