Découvrir Scilab/Gestion des fichiers

Un livre de Wikilivres.
Aller à : navigation, rechercher

Table des matièresIndex



10. Gestion des fichiers


Nous avons vu précédemment que l'on pouvait définir une fonction ou un programme dans un fichier texte, puis appeler ce fichier texte avec l'instruction exec(), ce qui avait le même effet que taper la fonction ou le programme (voir Programmation).

Mais Scilab possède aussi d'autre possibilités de gestion de fichier.

Informations sur les fichiers[modifier | modifier le wikicode]

La commande fileinfo('nom_de_fichier') donne des informations sur les fichiers (au sens large d'Unix, c'est-à-dire y compris les unités de stockage et les répertoires)[1]. Elle renvoit un vecteur de 13 nombres :

  1. Taille du fichier, en nombre de blocs (un bloc = 512 octets).
  2. Mode du fichier : autorisations d'accès actuel (en lecture, écriture, modification), sous la forme d'un nombre entier.
  3. L'identifiant du propriétaire du fichier.
  4. L'identifiant du groupe du fichier.
  5. Le numéro de lecteur.
  6. La date de la dernière modification des données.
  7. La date de la dernière modification de status.
  8. La date de la dernier accès.
  9. Si le fichier est un périphérique (fichier spécial) : le type de lecteur.
  10. La taille de blocs utilisée par le système d'exploitation pour les entrées-sortie.
  11. Le nombre de blocs alloués.
  12. Le numéro de nœud d'index (i-number, inode number).
  13. Le nombre de liens matériels (noms de fichiers différents pointant sur le même fichier).

Si le fichier n'existe pas, tous les nombres sont des NaN (not a number) ; la fonction retourne donc la matrice vide.

Par exemple, pour vérifier si un fichier existe (ou si un répertoire existe, ou si un lecteur est monté), on peut utiliser

fileinfo("nom_de_fichier")~= [ ]

Manipulation des répertoires[modifier | modifier le wikicode]

Scilab dispose d'un certain nombre de commandes de type Unix permettant de manipuler les chemins d'accès aux fichiers, les répertoires (dossiers) :

  • pwd (print working directory) : affiche le répertoire courant ;
  • chdir(chemin), cd chemin (change directory) : change le répertoire courant ;
  • mkdir(chemin) (make directory), createdir(chemin) : crée un répertoire ;
  • ls (list), listfile : affiche la liste des fichiers dans le répertoire courant ;
  • dir (directory) : idem, mais avec un affichage différent.

Par ailleurs, il existe des variables prédéfinies relatives aux répertoires :

  • home : répertoire où les fichiers sont lu ou enregistrés par défaut ;
  • SCIHOME : répertoire où sont les fichiers de configuration personnalisés ;
  • WSCI : répertoire d'installation de Scilab.

Lecture/écriture d'une matrice en format texte[modifier | modifier le wikicode]

Les fonctions read() et write() permettent de lire et d'écrire les valeurs d'une matrice ou d'un vecteur dans un fichier au format texte. Cela permet entre autres d'échanger les données avec d'autres logiciels, comme par exemple un tableur.

Il est possible d'appliquer un format aux données dans un format proche du Fortran.

Syntaxe :

    write (nom_de_fichier, a [, format])
[x] = read (nom_de_fichier, m, n [, format])

Paramètres :

  • nom_de_fichier : Chaîne de caractère correspondant au nom du fichier.
  • a : matrice, vecteur ou chaîne de caractères ;
  • m : entier, nombre de ligne à lire ; le paramètre m=-1 permet de lire toutes les lignes du fichier ;
  • n : entier, nombre de colonnes à lire ;
  • format : chaîne de caractère décrivant le format des données selon la syntaxe Fortran.

La commande csvRead() permet de lire des fichiers au format CSV. Cela permet par exemple de lire des fichiers exportés depuis un tableur, comme Microsoft Office Excel ou bien LibreOffice Calc :

A = csvRead(nom_de_fichier);

La syntaxe complète est :

csvRead(A, nom_de_fichier, separateur_colonnes, separateur_decimal, conversion)

  • separateur_colonne est une chaîne de caractères contenant un seul caractère, le séparateur de colonnes (la virgule par défaut), ou bien un vecteur de caractères s'il y a plusieurs séparateurs de colonne ; par exemple ":" ou bien [",", ":"] ;
  • separateur_decimal est une chaîne de caractères contenant un seul caractère, le séparateur décimal (point ou virgule, point par défaut) ;
  • conversion est une chaîne de caractères valant soit string (les valeurs sont des chaînes de caractères), soit double (les valeurs sont des nombres).

De même, la commande csvWrite() permet de créer des fichiers CSV, avec par défaut une virgule (comma) comme séparateur de champ ; le format de la commande est

csvWrite(A, nom_de_fichier)

où A est la variable (matrice) dont le contenu va être écrit dans le fichier. La syntaxe complète est :

csvWrite(A, nom_de_fichier, separateur_colonnes_ separateur_decimal, precision, commentaire)

  • separateur_colonne et separateur_decimal : comme précédemment ;
  • precision est la précision des réels, au format Fortran ;
  • commentaire est une chaîne de caractères qui sera mis sur la première ligne (typiquement des informations sur le fichier ainsi que les en-têtes de colonne).


Voir aussi la commande fscanfMat() dans la section Exploitation de fichiers texte ci-dessous.

Exemples[modifier | modifier le wikicode]

x=linspace(0, 2*%pi, 100)';
y=sin(x);
write("sinus.txt", [x y], "(F6.3,1X,F6.3)");

Cet exemple écrit la table de la fonction sinus dans le fichier sinus.txt, chaque ligne représente un point.

sinus.txt:
 0.000  0.000
 0.063  0.063
 0.127  0.127
 0.190  0.189
 0.254  0.251
...

Si le format est omis, Scilab décide d'un format approprié. La commande :

write("sinus.txt", [x y]);

écrira le fichier suivant :

sinus.txt:
   0.0000000000000000        0.0000000000000000
  6.34665182543392575E-002  6.34239196565645064E-002
  0.12693303650867852       0.12659245357374926
  0.19039955476301776       0.18925124436041019
  0.25386607301735703       0.25114798718107922
  0.31733259127169627       0.31203344569848712
...

Inversement le fichier temperature.txt contient l'heure, la temperature et l'humidité relevé.

temperature.txt:
 18    -1 86
 17    -1 84
 16  -0.7 85

Sa lecture se fera par la commande read() :

a=read ("temperature.txt", -1, 3);

Il est plus simple ici de laisser scilab décider du format de lecture. Seul le nombre de colonnes est indiqué, le nombre de ligne est mis à -1 pour indiquer à scilab de lire l'intégralité du fichier. La matrice a de type flottant contient :

 
 a  =
 
    18.  - 1.     86.  
    17.  - 1.     84.  
    16.  - 0.7    85.

Syntaxe Fortran[modifier | modifier le wikicode]

  • An : chaîne de caractères de taille n ; des blancs sont éventuellement ajoutés à gauche ; si n n'est pas précisé, Scilab écrit simplement la chaîne de caractères sans blanc ;
  • Em.n : notation exponentielle (réel à virgule flottante) de n caractères (y compris les signes +/-, le séparateur décimal « . » et le symbole de l'exposant « e »), dont m chiffres après la virgule (donc m + 1 chiffres significatifs) ; on doit avoir nm + 7 ;
  • Fm.n : notation décimale (réel à virgule flottante) de n caractères (y compris le signe +/- et le séparateur décimal « . »), dont m chiffres après la virgule ;
  • In : nombre entier (integer) de n chiffres ; des blancs sont éventuellement ajoutés à gauche ;
  • Tc : tabulation ;
  • nX : place n espaces horizontaux.

Lecture d'un fichier Microsoft Office Excel[modifier | modifier le wikicode]

Scilab peut lire des fichiers Excel. La version 5.4 de Scilab peut lire les fichier de Microsoft Office Excel 2003 (format BIFF8), portant l'extension .xls, mais pas les fichiers .xlsx.

La première étape consiste à ouvrir le fichier Excel, avec la commande xls_open() ; puis, on lit les données avec la commande xls_read().

Prétraitement d'un fichier[modifier | modifier le wikicode]

Dans certains cas, le fichier contient des données inutiles qu'il convient d'éliminer avant de l'ouvrir dans Scilab. Rappelons que des commandes du système d'exploitation peuvent être lancées depuis Scilab grâce à la commande unix_g().

Par exemple, avec un système unix, il est possible de nettoyer un fichier texte en exécutant des commandes de type sed, awk et grep.

Pour plus de détails voir : Programmation Bash/Commandes shell.

Sauvegarde de variables en binaire[modifier | modifier le wikicode]

Il est possible d'exporter le résultat d'un calcul dans un fichier, ce qui permet de le réutiliser pour une autre fois. Ceci se fait avec la commande save :

save (fichier, a, b, c, ...)

Cela enregistre les variables a, b, c, ..., dans le fichier de nom fichier. Si aucune variable n'est spécifiée, toutes les variables de l'environnement de travail sont enregistrées.

Ce résultat peut ensuite être réimporté avec la commande load :

load (fichier, a, b, c, ...)

Cela lit les variables a, b, c, …, présentes dans le fichier de nom fichier. Il s'agit du nom des variables tel qu'il a été spécifié lors de la commande save. De même que précédemment, si aucun variable n'est spécifiée, toutes les variables présentes dans le fichier sont chargées.

Le fichier produit est un fichier binaire. Chaque variable est représentée par :

  • le nom de la variable, sur 24 octets :
    • chaque caractère correspond à un code : 10 à 35 pour les minuscules de « a » à « z », -35 à -10 pour les capitales de « Z » à « A » ; taper str2code('chaine') (obsolète) ou ascii('chaine')pour avoir la suite de codes correspondant à la chaîne chaine ;
    • le nom se termine par le code 40 ;
  • un code représentant le type de la variable : de 1 pour une matrice de réels en virgule flottante, 2 pour un polynôme, 10 pour un chaîne de caractères… taper type(X) pour avoir le code du type de la variable X ;
  • puis suit la description de la variable, notamment le nombre d'éléments pour les matrices, chaînes… cette description dépend du type de la variable ;
  • enfin vient la valeur de la variable.

L'instruction listvarinfile('nom_de_fichier') permet d'avoir la liste des variable contenues dans un fichier et leur description.

Enregistrer un graphique[modifier | modifier le wikicode]

Pour la création de graphiques, voir Graphiques et sons.

Scilab permet de sauvegarder des graphiques sous plusieurs formats. Il faut au préalable donner un numéro à la fenêtre graphique, en indiquant scf(numéro) avant les instructions de tracé.

La syntaxe générale des fonctions d'export est la suivante :

xs2format (id, fichier)

  • id : entier, l'identifiant du graphique à exporter. Cet identifiant peut être obtenu par la fonction gcf ;
  • fichier : chaîne de caractère, le nom du fichier, sans oublier l'extension, dans lequel le graphique sera enregistré.

Les fonctions sont :

  • xs2bmp : format BMP (bitmap, Microsoft Windows);
  • xs2emf : format EMF (enhanced metafile, Microsoft Windows) ;
  • xs2eps : format EPS (encapsulated PostScript) ;
  • xs2fig : format Xfig ;
  • xs2gif : format GIF (Graphics Interchange Format) ;
  • xs2ppm : format PPM (portable pixmap) ;
  • xs2ps : format PS (PostScript).

Exemple :

Courbe sinus et cosinus.
f = gcf ();
x = linspace (0, 2*%pi, 200)';
plot (x, [sin(x), cos(x)]);
xs2gif (f, "exemple_scilab_sin_cos.gif");

L'export de graphiques sous scilab semble se faire par copie d'écran, cela signifie qu'il peut y avoir des problèmes si lors de la commande xs2…, la fenêtre contenant le graphique n'est pas clairement visible à l'écran.

Lire un fichier d'image[modifier | modifier le wikicode]

Scilab ne dispose pas en natif d'instruction permettant de lire un fichier d'image. Il existe toutefois des modules externes de traitement d'image que l'on peut charger grâce au gestionnaire de modules Atoms[2]. Citons :

  • SIP (Scilab Image Processing toolbox)[3] ;
  • SIVP (Scilab Image and Video Processing toolbox)[4] ;
  • IPD (Image Processing Design toolbox)[5].

Avec SIP et SIVP[6][7], on charge une image dans une variable avec l'instruction

image = imread("nom_de_ficher")

et on l'affiche avec l'instruction

imshow(image)

Avec IPD[8], on charge une image dans une variable avec l'instruction

image = ReadImage("nom_de_fichier")

et on l'affiche avec l'instruction

ShowImage(image)

Enregistrer et lire des fichiers de sons[modifier | modifier le wikicode]

Lorsque la variable x est un vecteur, on peut le sauvegarder sous la forme d'un son, dans un fichier de type .wav. Le son correspond à des varations de pression de l'air, ou des variations de la tension d'alimentation du haut-parleur, s de la forme

s(ti ) = x(i )

avec

ti  = i

ƒ étant la fréquence d'échantillonnage. Par défaut, ƒ vaut 22 050 hertz (une valeur de x correspond à 1/22 050 seconde).


Pour plus de détails voir : Découvrir Scilab/Graphiques et sons#Sons.

La création du fichier se fait avec la fonction savewave

savewave('nom_de_fichier', x)

Il faut bien s'assurer qu'il s'agit d'une matrice colonne.

On peut aussi définir une autre fréquence d'échantillonnage entière :

savewave('nom_de_fichier', x, f)

Un fichier .wav peut être mis dans une matrice avec la fonction loadwave :

x = loadwave('nom_de_fichier')

chaque ligne de la matrice correspondant alors à un canal. On peut ensuite jouer ce son dans Scilab avec l'instruction playsnd()

playsnd(x)

Voir aussi Graphiques et sons.

Gestion avancée des fichiers[modifier | modifier le wikicode]

Lecture/Ecriture « à la sauce » C[modifier | modifier le wikicode]

Différentes fonctions sont directement inspirées de la syntaxe du langage C.

  • [fd, err] = mopen (fichier, mode)
    
    Ouverture du fichier de nom fichier. Le mode d'ouverture est "r" pour lecture, "w" pour écriture et "a" pour ajout.
    La fonction retourne un scalaire « descripteur » fd qui sert à identifier le fichier dans les fonctions suivantes. Le code d'erreur peut être récupéré par la variable err, il vaut 0 si l'ouverture s'est déroulée correctement.
  • mfprintf (fd, format [, x1 [, x2,]])
    
    Écriture dans le fichier d'identifiant fd. Le paramètre format est une chaîne de caractère décrivant le formatage des données. Cette fonction est équivalente à la fonction fprintf du langage C (voir Programmation C-C++/Entrée / sortie de base#La fonction printf).
  • y(1,1:3) = mfscanf(1, fd, "%f %f %f\n") // ou bien
    y(1,1:3) = mfscanf(fd, "%f %f %f\n")
    
    balaie (scan) le fichier numéro fd de manière séquentielle, et récupère les trois premières données et les met dans la première ligne d'une matrice de trois colonne appelée y ; le premier nombre niter (ici « 1 ») indique que l'opération est faite niter fois (le paramètre est optionnel et la valeur par défaut est 1)
    y(2,1:3) = mfscanf(-1, fd, "%f %f %f\n")
    
    continue l'opération de rapatriement et met les données dans les lignes suivantes de la matrice, jusqu'à la fin du fichier (c'est le sens de niter valant -1) ;
  • mclose (fd)
    
    Ferme le fichier d'identifiant fd

Les fonctions mfscanf() et mfprintf() sont plus « rigides » que csvRead() et csvWrite() par exemple, puisqu'elle nécessitent de définir strictement la structure d'une ligne de fichier alors que les csv*() n'ont besoin que du séparateur. En revanche, elles sont plus rapides, ce qui est appréciable pour les grands volumes de données.

Exploitation de fichiers texte[modifier | modifier le wikicode]

Le format texte (ASCII ou Unicode), du fait de son caractère universel, sert fréquemment de format d'échange entre logiciels. Il est donc intéressant de se focaliser sur les spécificités de ce format. Les fonctions read() et csvRead() sont simples d'utilisation, mais ne sont plus applicables pour les fichiers très grands.

Lire une matrice de nombres[modifier | modifier le wikicode]

La commande fscanfMat permet de lire directement une matrice dans un fichier texte (ASCII ou UTF-8). Dans sa syntaxe de base

M = fscanfMat("nomfichier");

la fonction crée une matrice de nombres M à partir du fichier texte nomfichier, en éliminant l'en-tête (les premières lignes qui contiennent des caractères non numériques). On peut lui demander de mettre le texte de l'en-tête dans une variable :

[M, entete] = fscanfMat("nomfichier");

Il est possible d'indiquer le format des données :

M = fscanfMat("nomfichier", "format");

ou format est une chaîne de caractère qui peut être de la forme %type, par exemple :

  • %e : réel en notation exponentielle ;
  • %f : réel en notation décimale (point flottant) ;
  • %g : réel en notation exponentielle si l'exposant est inférieur à -4, notation décimale sinon ;
  • %lg : réel long (double précision) ;
  • %d ou %i : nombre entier ;
  • %x : entier hexadécimal.

La chaîne peut également contenir la largeur et la précision du nombre : %largeur.précisionf par exemple. La largeur est le nombre minimum de caractères que comporte un nombre. La signification de la précision dépend du type :

  • pour un entier (%d, %i, %x) : nombre minimum de chiffre ;
  • pour un réel en notation exponentielle ou décimale (%e, %f) : nombre de chiffres après la virgule ;
  • pour un réel en notation « adaptative » (%g) : nombre de chiffres significatifs.

Lire les lignes une par une[modifier | modifier le wikicode]

La fonction mgetl lit une ou plusieurs lignes d'un fichier texte

txt = mgetl ('nomfichier', m)
txt = mgetl (fd, m)

Si le fichier a été ouvert (avec mopen, il dispose d'un descripteur fd qui permet d'y faire référence ; sinon, on peut utiliser le nom du fichier. Si m est omis ou vaut -1, la fonction lit toutes les lignes. Si m est un entier strictement positif, la fonction lit m lignes (accès séquentiel). La variable txt est une matrice colonne, chaque ligne correspondant à une ligne du fichier.

La commande stripblanks(txt) enlève les espaces situés au début et à la fin des lignes.

Découper une ligne en colonnes[modifier | modifier le wikicode]

Si l'on connaît les positions (index) des débuts de colonne, les nombres c1, c2, …, cn, on peut utiliser la commande part() pour extraire une colonne. Par exemple, pour extraite la colonne 5 :

p = part(txt, [c5, c6 - 1])

On peut également séparer les différentes colonnes pour les mettre dans un vecteur avec

cellules = strsplit(txt, [c1, c2,, cn])

Une ligne — une chaîne de caractères — contient souvent des délimiteurs. S'il s'agit d'une chaîne de caractères fixes, on peut utiliser la commande tokens() :

t = tokens('a = 5', '=')

crée la matrice ['a ' ; '=' ; ' 5'].

Si les séparateurs sont variables, on a intérêt à faire appel aux expressions régulières (voir Programmation > Expressions régulières). Par exemple, si les colonnes sont complétées par des caractères d'espacement (espaces, tabulations) en nombre indéterminé, on peut utiliser

cellules = strsplit(txt, '/\s+/)

Considérons par exemple le fichier roisdefrance.txt

Clovis Ier      466-511
Clodomir        495-524
Thierry Ier     485-534
Théodebert Ier  504-548

La séparation entre le nom du roi et la date est constituée de deux espaces ou plus. On veut créer une matrice dont la première colonne contient le nom du roi, la deuxième sa date de naissance et la troisième sa date de mort. On peut par exemple écrire

// lecture du fichier
fd = mopen('roisdefrance.txt');
texte = mgetl(fd, -1); // texte(i) contient la i-ème ligne
mclose(fd);

n = size(texte, 'r');

cellules = [];

// séparation des colonnes
for i = 1:n
    cellules(i,:) = strsplit(texte(i), '/\s{2,}|-/')'
end

disp(cellules');

Fonctions de gestion des fichiers[modifier | modifier le wikicode]

Notes et références[modifier | modifier le wikicode]

  1. c'est une interface de la fonction C stat()
  2. http://atoms.scilab.org/categories/Image_Processing
  3. http://atoms.scilab.org/toolboxes/SIP
    http://siptoolbox.sourceforge.net/
  4. http://atoms.scilab.org/toolboxes/SIVP
    http://sivp.sourceforge.net/
  5. http://atoms.scilab.org/toolboxes/IPD
  6. http://siptoolbox.sourceforge.net/doc/sip-0.7.0-reference/
  7. [anglaisDocumentation SIVP]
  8. [anglaisDidacticiel IPD]

Voir aussi[modifier | modifier le wikicode]

Dans Wikipédia



Structures de données avancées < > Équivalences Matlab-Scilab