Compiled blog: Outils pour convertir des dictionnaires

Pour faciliter la lecture, nous avons rassemblé dans cette page tous les outils disponibles (à notre connaissance) pour permettre des conversions entre les différents formats de dictionnaires, y compris ceux qui ne sont pas issus du projet “Polyglotte”. Le tableau ci-dessous fait la synthèse des conversions possibles et des scripts ou logiciels les permettant. Les scripts tab2wb (?), wb2tab (?), apertium2tabdict.sh et apertium2tabling.sh, ainsi que le logiciel Linguae, sont issus du projet “Polyglotte”.

Voir la page sur les formats de dictionnaires pour plus de détails sur ceux-ci

Scripts de conversion des lexiques Apertium au format texte tabulé

1/ Ces scripts apertium2tabdict.sh et apertium2tabling.sh ont une dépendance : lt-expand, qui doit être préalablement installée (paquet lttoolbox disponible notamment sous Linux Ubuntu hardy et Intrepid)

téléchargement des scripts
apertium2tabdict.sh
apertium2tabling.sh

2/ Ils permettent de sortir 6 lexiques (lexique total, lexique sans nom propre, lexique des noms propres, dans les deux sens “langue1-langue2” et “langue2-langue1”). Les lexiques des noms propres ne comportent que les noms propres qui diffèrent entre les deux langues.
3/ architecture des lexiques obtenus :
a) apertium2tabdict.sh : mot langue 1 | [code grammatical mot langue 1] mot langue 2 [code grammatical mot langue 2]
(cette architecture, avec le mot seul dans le premier champ, convient à la fonction de scan des logiciels StarDict et QStarDict.)
b) apertium2tabling.sh : mot langue 1 [code grammatical mot langue 1] | mot langue 2 [code grammatical mot langue 2]
(cette autre architecture, équilibrée, convient au logiciel Linguae, notamment pour la création de lexiques par héritage)
4/ procédure
- téléchargez le script apertium2tabdict.sh ou apertium2tabling.sh et placez le dans le répertoire qui vous convient; rendez-le exécutable.
- installer le paquet lttoolbox (si ce n'est déjà fait) pour disposer de lt-expand.
- récupérer un document xml Apertium de type “apertium-l1-l2.l1-l2.dix” sur le svn sourceforge d'Apertium et placez-le dans le répertoire où vous avez mis le script.
- nettoyez votre bureau (les lexiques obtenus seront placés sur le bureau)
- dans un terminal, placez-vous dans le répertoire où vous avez mis le script (commande “cd” + chemin du répertoire)
- lancez la commande : ”./apertium2tabdict.sh apertium-l1-l2.l1-l2.dix dicotemp” ou ”./apertium2tabling.sh apertium-l1-l2.l1-l2.dix dicotemp” (en remplaçant apertium-l1-l2.l1-l2.dix par le fichier apertium que vous avez téléchargé et que vous voulez convertir).
5/ lexiques obtenus sur le bureau :
total.tab : lexique complet issu d'Apertium dans le sens originel des langues du document Apertium. Il pourra être renommé “lexicapertium-l1-l2.tab”
totalinv.tab : lexique complet issu d'Apertium dans le sens inverse des langues du document Apertium. Il pourra être renommé “lexicapertium-l2-l1.tab”
snp.tab : lexique sans nom propre issu d'Apertium dans le sens originel des langues du document Apertium. Il pourra être renommé “lexicapertium-l1-l2_snp.tab”
snpinv.tab : lexique sans nom propre issu d'Apertium dans le sens inverse des langues du document Apertium. Il pourra être renommé “lexicapertium-l2-l1_snp.tab”
npdiff.tab : lexique des noms propres (à l'exclusion de ceux qui sont identiques entre les deux langues) issu d'Apertium dans le sens originel des langues du document Apertium. Il pourra être renommé “lexicapertium-l1-l2_np.tab”
npdiff.tab : lexique des noms propres (à l'exclusion de ceux qui sont identiques entre les deux langues) issu d'Apertium dans le sens originel des langues du document Apertium. Il pourra être renommé “lexicapertium-l2-l1_np.tab”
Par convention, on ajoute “_ling” aux noms des lexiques obtenus avec le script apertium2tabling.sh
les fichiers DOCTEMP (sur le bureau) et dicotemp (dans le même répertoire que le script) sont des documents temporaires qu'il suffit de supprimer dès que le script a fini son ouvrage.
6/ Important : renommer et classer les lexiques obtenus avant de lancer de nouveau le script sur un autre document Apertium, sinon votre premier travail sera écrasé…
7/ Les lexiques obtenus peuvent être ouverts directement par certains logiciels (comme Linguae). Ils peuvent être aussi facilement convertis au format “dict” (pour StarDict et QStarDict) avec “stardict-editor” (ou Linguae).

stardict2text

Exécutable en ligne de commande, qu'on trouve dans /usr/lib/stardict-tools/ après installation du paquet stardict-tools . Il permet de décompiler. La syntaxe est : /usr/lib/stardict-tools/stardict2text mondico.ifo

Le .dict ne doit pas être compressé (dict et non dict.dz) :pour décompresser le *.dict.dz, renommage du fichier en *.dict.gz suivi d'un clic-droit/extraire ici.

tabfile

Exécutable en ligne de commande, qu'on trouve dans /usr/lib/stardict-tools/ après installation du paquet stardict-tools. Il permet de compiler. La syntaxe est : /usr/lib/stardict-tools/tabfile mondico.txt

Les 2 outils précédents proposent de “compiler” un dictionnaire texte : pour cela, il faut que ce fichier texte respecte une certaine syntaxe :

Être encodé en UTF-8.
Chaque ligne du fichier doit correspondre à un mot et sa définition.
La ligne est constituée :
1. du mot
2. suivi d'une tabulation
3. suivi de la définition (si on souhaite que la définition soit sur plusieurs lignes, les séparer par \n ).

Makedict

http://sourceforge.net/project/showfiles.php?group_id=95155&package_id=160978 Il convertit de : dictd, dsl, sdict, stardict, xdxf vers dictd (expérimental), stardict, xdxf. Pour le compiler, téléchargez l'archive et suivre les instructions du fichier README.
Exemple d'utilisation (conversion d'un fichier xdxf (XML) en fichier Stardict) :

./makedict -i xdxf -o stardict exemple.xdxf

Dictconv

Le seul outil permettant de convertir les fichiers de babylon de type ”.bgl”. (disponible dans les dépôts sous ubuntu). Il convertit des dictionnaires de Babylon, Freedict, Sdictionary et Stardict vers les dictionnaires au format DICT, plain text et StarDict.
Exemple : dictconv -o dico.ifo dico.BGL

Attention, ça ne marche qu'avec les anciens formats de babylon !

wb2tab & tab2wb

Convertisseur de dictionnaires wb en csv (avec tabulation comme séparateur). Le format csv est lu par la plupart des tableurs : openOffice Calc, Excel, etc… Il est aussi un bon point de départ pour une conversion vers un autre format de dictionnaire.

wb2tab

wb2tab.c

#include <stdio.h>
 
int main(int narg, char* argv) {
char c;
int i=0, drapeau=1;
while ((c = getchar()) != EOF){
    i++;
    if(i==32){
        drapeau=1;
        putchar('\t');
    }
    if(i==85){
        putchar('\n');
        i=1;
        drapeau=1;
    }
    if (c=='\x00'){
        drapeau=0;
    }
    if(drapeau==1){
        putchar(c);
    }
}
putchar('\x0A');
return 0;
}

Compilation (installer build-essential):

gcc -o wb2tab wb2tab.c

Exécution:

./wb2tab <fichier.wb >fichier.csv

Le format obtenu est iso-blabla. Si on souhaite convertir au format stardict, ne pas oublier de convertir le fichier obtenu en utf-8, par exemple :
iconv -f ISO-8859-1 -t UTF-8 fichier.csv > fichierUTFf8.csv

tab2wb

#include <stdio.h>
 
int main(int narg, char* argv) {
char c;
int i=0, drapeau=0;
while ((c = getchar()) != EOF){
 if(c=='\n'){
  i++;
  while(i<86){
   putchar('\x00');
   i++;
  }
  i=0;
  drapeau=0;
 }
 else if(c=='\t'){
  i++;
  while(i<32){
   putchar('\x00');
   i++;
  }
  drapeau=1;
 } else if(drapeau && (i<85)||(!drapeau && (i<31))){
  i++;
  putchar(c);
 }
}
return 0;
}

tab2xdxf : convertisseur de dictionnaires texte en xdxf

Rajouter l'en-tête et supprimer les 2 dernières lignes.

Exemple d'en-tête :

<?xml version="1.0" encoding="UTF-8" ?>
<xdxf lang_from="FRE" lang_to="FRE" format="visual">
<full_name>Nom du dictionnaire</full_name>
<description>blablabla </description>

Compilation :

 gcc -o tab2xdxf tab2xdxf.c

et exécution :

./tab2xdxf <DicoAvant.txt >DicoApres.xdxf

#include <stdio.h>
 
 
int entete(void){
 return 0;
}
 
int baliseouvrante(char* t){
 int i=0;
 putchar('<');
 while(t[i]!='\0'){
  putchar(t[i]);
  i++;
 }
 putchar('>');
 return 0;
}
 
int balisefermante(char* t){
 int i=0;
 putchar('<');
 putchar('/');
 while(t[i]!='\0'){
  putchar(t[i]);
  i++;
 }
 putchar('>');
 putchar('\n');
 return 0;
}
 
int baliseautofermante(char* t){
 int i=0;
 putchar('<');
 while(t[i]!='\0'){
  putchar(t[i]);
  i++;
 }
 putchar('/');
 putchar('>');
 putchar('\n');
 return 0;
}
 
int balises(char* t){
 baliseouvrante(t);
 balisefermante(t);
 return 0;
}
 
int main(int narg, char** argv) {
 int i, drapeau=1, drapeauparenthese=0;
 char* def="ar";
 char* par="tr"; 
 char* mot="k";
 char* sen="sens";
 char* bq="blockquote";
 char* tra="traduction";
 char* syn="synonyme";
 char* it="i";
 char* gras="b";
 char* kref="kref";
 char c;
 for(i=0;i<narg;i++){
  while(argv[i]!='\0'){
   i++;
  }
 }
 entete();
 baliseouvrante(def);
 putchar('\n');
 baliseouvrante(mot); 
 while ((c = getchar()) != EOF){
  if(c=='\t'){
   drapeau=0;
   balisefermante(mot);
  }else if (c=='\n'){
   putchar('\n');  
   balisefermante(def);
   baliseouvrante(def);
   putchar('\n');
   baliseouvrante(mot);
   drapeau=1;
  }else{
   putchar(c);
  }
 }
 putchar('\x0A');
 return 0;
}

utilitaires divers

tidy

cf ici. tidy (disponible dans dépôts dans les distributions debian, ubuntu, …) permet notamment la conversion de HTML en XHTML : ce qui permet ensuite d'utiliser des feuilles XSL, par exemple pour convertir en XDXF.

tidy -clean --drop-proprietary-attributes yes --drop-font-tags yes --drop-empty-paras yes -utf8 --doctype omit -numeric -asxhtml -o exemple.xhtml exemple.html

rtf2xml

Un petit utilitaire en python, qui transforme le format microsoft rtf en xml. il est téléchargeable ici (j'ai dû télécharger le paquet python-profiler pour que ça marche). Problème avec les caractères non ascii ? FIXME

rtf2xml monfichier.rtf

Convertisseur de polices non-latines (symbol ou greekttf pour le grec, etc.) en utf-8

(ou “comment échapper aux bidouillages microsoftiens”)…
Lorsqu'on récupère des lexiques originellement au format doc ou html, composés de caractères non-latins, on risque d'être confronté au problème suivant : les caractères visiblement non-latins peuvent s'avérer être des caractères latins, affublés d'une police comme “symbol”. Pour remédier à ça, voici un petit programme en C qui convertit ces caractères en l'unicode correspondant, à compiler ( gcc -o convertcarac convertcarac.c) et exécuter :

./convertcarac lexiquecarac.txt <avant.txt >apres.txt

avec lexiquecarac.txt un fichier de conversion des caractères (encodé en utf-8), dont voici un mini-exemple :

V   ω
a   α
b   β

avant.txt quant à lui est un fichier texte de la même structure que décrite plus haut (paragraphe tabfile), encodé lui aussi en utf-8 :

apo   loin de
agV   conduire

le code convertira les éléments de la première colonne uniquement. apres.txt devrait contenir après exécution :

απο   loin de
αγω   conduire

Le code :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define ALPHABETMAX 100
 
int creetableau(FILE* fichier , char tab[ALPHABETMAX][2][5], int* taille){
 int i=0, j=0, k=0, drapeau=0;
 char c;
 while((c = getc(fichier)) != EOF){
  if(c=='\t'){
   drapeau=1;
   j=1;
   k=0;  
  }else 
  if(c=='\n'){
   drapeau=0;
   j=0;
   i++;
   k=0;   
  }else{
   tab[i][j][k]=c;
   tab[i][j][++k]='\0';
  }
 }
 *taille=i;
 return 0;
}
 
int apptableau(int taille, char d[5], char tab[ALPHABETMAX][2][5], int* ind){
 int res=-1, i=0, victoire=1, j=0; 
 for(i=0;i<taille;i++){
  victoire=1;
  j=0;
  while( (d[j]!='\0') && (tab[i][0][j]!='\0') ){
   if (d[j]!=tab[i][0][j]){
    victoire=0;
    break;
   }
   j++;
  }
  if (victoire && (j>0)){
   *ind=i;
   res=1;
  }
 }
 return res;
}
 
 
int main(int narg, char** argv) {
 char tab[ALPHABETMAX][2][5]; 
 int i=0, j=0, k=0, drapeau=1, ind=0, res=0, taille=0;
 char c,e;
 char d[5];
 FILE* lexique;
 lexique=fopen(*(argv+1),"r");
 if(lexique==NULL){
  printf("Pas trouvé de fichier.\n");
 }
 res=creetableau(lexique, tab, &taille);
 fclose(lexique);
 while ((c = getchar()) != EOF){
  if (c=='\n'){
   putchar('\n');  
   drapeau=1;
  }else if (c=='\t'){
   putchar('\t');  
   drapeau=0;
  }else if (drapeau){
   i=1;
   *d=c;
   if((unsigned char)c >192){ /* unicode sur 2 octets*/
    e = getchar();
    *(d+(i++))=e;
   }
   if((unsigned char)c >224){/* unicode sur 3 octets*/
    e = getchar();
    *(d+(i++))=e;   
   }
   if((unsigned char)c >240){/* unicode sur 4 octets*/
    e = getchar();
    *(d+(i++))=e;   
   }
   *(d+i)='\0';
   if ((res=apptableau(taille,d,tab,&ind))==1){
    k=0;
    while(tab[ind][1][k] !='\0'){
     putchar(tab[ind][1][k]);
     k++;
    }  
   }else{
    i=0;
    while(*(d+i)!='\0'){   
     putchar(*(d+(i++)));
    }
   }
  }else{
   putchar(c);
  }
 }
 putchar('\x0A');
 return 0;
}

Convertisseur csvshtooka2ankicard

Script Python qui permet à partir de la table csv du projet “lexique” de shtooka de créer des csv importables par anki.

Récupérer la table multi-lingue ici.
La sauvegarder sous le nom “table.csv”.
Appeler csvshtooka2ankicard.py dans le terminal :

./csvshtooka2ankicard.py table.csv

On récupère dans le même répertoire des fichiers csv bilingues (autant que de langues disponibles), prêts à l'import sous anki (en spécifiant '\t' comme séparateur).

Le code de csvshtooka2ankicard.py :

#!/usr/bin/python
 
import string
import sys
import csv
 
delim='\t'
def readCsv(csvFilename, delim):
 dialect = csv.Sniffer().sniff(open(csvFilename, 'r').read())
 return csv.reader(open(csvFilename, 'r'), dialect=dialect, delimiter=delim)
 
if len(sys.argv) < 2:
 print 'Usage: %s file.csv' % sys.argv[0]
elif len(sys.argv) >2:
 print 'Usage2: %s file.csv' % sys.argv[0]
else:
 csvFile=sys.argv[1]
 data = readCsv(csvFile,delim)
 fichiersortie=[]
 for ir, row in enumerate(data):
  if ir==0:
   for ic, column in enumerate(row):
    if ic>3:
     nomfichier=column
     fichiersortie.append(csv.writer(open(nomfichier + ".csv", "wb"),delimiter=delim))
  elif ir>0:
   if row[2]=="":
    pivot=row[3]
   else:
    pivot=row[3]+" ("+row[2]+")"
   for ic, column in enumerate(row):
    if ic>3:
     if column<>"":
      fichiersortie[ic-4].writerow([pivot,column])

csv2ods

Un petit utilitaire qui permet de convertir un (ou des) fichiers csv en un document openOffice ods (tableur). (utilise la librairie ooolib -incluse dans le zip-)
À télécharger ici.
Exemple : csv2ods.py -d \t fichier.ods fichier1.csv fichier2.csv … fichierN.csv FIXME

Script créé par Guido Vicino et modifié par polyglotte (ajout du choix du délimiteur).

http://guidovicino.com/blog/2007/04/18/csv2odspy/csv2ods (it)

iconv

Conversion d'un encodage à un autre :
iconv -t UTF-8 -f ISO-8859-1 fichierOrigine.txt >fichierSortie.txt

XML-Twig

XML-Twig est une bibliothèque écrite en Perl, permettant des traitements de très gros fichiers XML : notamment, xml_split -s 30Mb -b wiki mongrosfichier.xml permet de tronçonner en fichier de 30 Mo mon fichier de départ. Se trouve en paquet sous toutes les bonnes distributions GNU/Linux; sous ubuntu, c'est ici.Source: polyglotte.tuxfamily.org

Compiled blog

Pages

Wednesday, July 27, 2011

Outils pour convertir des dictionnaires

Scripts de conversion des lexiques Apertium au format texte tabulé

stardict2text

tabfile

Makedict

Dictconv

wb2tab & tab2wb

wb2tab

tab2wb

tab2xdxf : convertisseur de dictionnaires texte en xdxf

utilitaires divers

tidy

rtf2xml

Convertisseur de polices non-latines (symbol ou greekttf pour le grec, etc.) en utf-8

Convertisseur csvshtooka2ankicard

csv2ods

iconv

XML-Twig

Show IP and Country

Search This Blog

LinkedIn Profile

About Me

Useful Links

Blog Archive

Tags

2Performant

ProZ.com Jobs

TranslatorsCafe.com: Recent Translation Jobs

TranslatorsTown.com

Total Pageviews

Popular Posts

SmartCAT

Wikipedia

Google Translate

2performant