AFAIK il n'y a aucun port existant de cette police vers une variante de contour. Voici cependant quelques détails et astuces qui pourraient vous aider sur le chemin.
Le t.fnt , Tektite, a été créé par (l'ancien?) ClySmic Software et probablement Ralph B Smith Jr, président / programmeur en chef / cuisinier / laveur de bouteilles . Il s'agit d'une police bitmap incluse avec le programme VFONT pour DOS et OS / 2. Il charge les polices de remplacement pour les systèmes VGA. Son nom donné par l'auteur est Tektite et décrit comme «une police de style« Architecte ».»
VFONT peut être téléchargé dans les archives CVFONT.ZIP et CVFONTA.ZIP. La police Tektite fait partie de cette dernière. Le premier est une ancienne version uniquement pour DOS.
VFONT et extraction:
L'archive comprend le programme DOS, VFONT.COM, le programme OS / 2 VFONT2.EXE, une base de données de polices VFONT.DAT et un fichier README.MAN. Le VFONT.DAT contient 13 polices bitmap stockées dos à dos. Pour extraire la police Tektite, procédez comme suit:
dd if=VFONT.DAT of=t.fnt bs=1 skip=28672 count=4096
Cela vous donne un fichier de police de type RAW, qui est celui inclus par exemple dans Slackware.
Chaque police fait 4096 octets. Ainsi, pour extraire les autres, changez simplement l' option de saut . C'est-à-dire c.fntqui vient après t.fntvous donne une valeur de saut de 28672 + 4096 = 32768. Toutes les polices sont incluses dans Linux, et pour faire une extraction complète, on pourrait faire:
#!/bin/bash
pos=0
for n in s sd r ro rl mu ml t c b m mr sc; do
dd if=VFONT.DAT of=$n.fnt bs=1 skip=$pos count=4096
((pos += 4096))
done
... ou bien sûr, téléchargez-le à partir de l'une des différentes distributions qui les incluent.
Ces fichiers peuvent être chargés directement dans le terminal par exemple:
setfont t.fnt
Nommer sous Linux
La police a été nommée sous Linux par les options du programme VFONT. Tektite l'a fait /T. Les autres polices sont également incluses, sont également nommées par l'option de ligne de commande pour VFONT. ( / S = s.fnt, / SD = sd.fnt, / RO = ro.fnt ... etc.)
Polices RAW
Le format de police RAW (obsolète mais reconnu) est le format de police le plus simple qui soit. Il n'a pas d'en-tête, pas de pied de page, pas d'octets d'échappement, etc. Il a généralement une largeur de 8 pixels (bits) - tout comme les polices VFONT. Ils ont toujours 256 glyphes.
À partir de cela, nous pouvons facilement calculer la hauteur en:
file_size (bits) 8 × 4096
h = -------------------- e.g. h = ------------- = 16
w × 256 8 × 256
Comme toutes les polices VFONT ont une taille de 4096, nous savons également qu'elles ont toutes une hauteur de 16 pixels (bits). Cela donne également que chaque glyphe fait 16 octets.
Rendu ASCII
Comme les polices sont conformes à la plage ASCII en ce qui concerne 0x20 (espace) - 0x7e (tilde), nous pouvons effectuer un rendu ASCII simple des glyphes.
Par exemple, la lettre Aa la position 65. Comme chaque glyphe est 8 × 16 = 128 bits, nous les avons à 128/8 = 16 octets.
Comme 65 × 16 = 1040, nous pouvons extraire le glyphe Apar (ici, y compris la conversion en binaire et le remplacement des 0 et des 1 pour le rendre plus lisible):
xxd -s 1040 -l 16 -b -c 1 t.fnt | cut -d' ' -f 2 | tr 0 ' ' | tr 1 '#'
Ce qui nous donne:
Output from | Data in file
command: | Binary: Hex: Offset Offset
| Hex: Dec:
| 00000000 00 410 1040
| 00000000 00 411 1041
## | 00011000 18 412 1042
## | 00011000 18 413 1043
#### | 00111100 3c 414 1044
# # | 00100100 24 415 1045
## ## | 01100110 66 416 1046
## ### | 01101110 6e 417 1047
#### # | 01111010 7a 418 1048
### ## | 11100011 e3 419 1049
## ## | 11000011 c3 41a 1050
## ## | 11000011 c3 41b 1051
| 00000000 00 41c 1052
| 00000000 00 41d 1053
| 00000000 00 41e 1054
| 00000000 00 41f 1055
En utilisant un simple code C, nous pouvons également rendre des images PBM simples. Voici un exemple de sortie de toutes les polices dans VFONT:
Modification avec FontForge
Si vous souhaitez travailler avec la police, je suppose que vous pouvez aller à FontForge . Comme il ne reconnaît pas les polices RAW, vous devez le convertir dans un autre format. L'une des conversions les plus simples pourrait être BDF. Une option consiste à utiliser les outils PSF de John Elliot . Convertissez d'abord de RAW en PSF puis PSF en BDF:
raw2psf t.fnt t.psf
psf2bdf t.psf t.bdf
Le fichier BDF peut maintenant être ouvert dans FontForge
Comme le processus est assez simple (et identique pour tous les VFONT), vous pouvez également utiliser ce script pour convertir directement au format BDF:
Exemple d'utilisation:
./raw2bdf Tektite t.fnt > t.bdf
Vous donne la police Tektite en tant que BDF.
#!/bin/bash
if [ $# -lt 2 ]; then
printf "Usage: %s <NAME> <raw-fnt-file>\n" $0
exit
fi
name=$1
file=$2
cat <<EOM
STARTFONT 2.1
FONT $name
SIZE 16 75 75
FONTBOUNDINGBOX 8 16 0 -4
STARTPROPERTIES 3
FONT_DESCENT 4
FONT_ASCENT 12
DEFAULT_CHAR 255
ENDPROPERTIES
CHARS 256
EOM
hexdump -ve '/1 "%02x\n"' "$file" | awk '
BEGIN {
n = 0;
}
(!((NR - 1) % 16)) {
if (n > 0)
print "ENDCHAR"
printf "STARTCHAR C00%02x\n"\
"ENCODING %d\n"\
"SWIDTH 666 0\n"\
"DWIDTH 8 0\n"\
"BBX 8 16 0 -4\n"\
"BITMAP\n",
n, n
++n
}
{
print $0
}
END {
print "ENDCHAR"
print "ENDFONT"
}
'
Autres versions
Il existe plusieurs versions modifiées de la police Tektite. Si vous le recherchez, ajoutez éventuellement «clysmic» à la phrase de recherche sur laquelle vous pouvez étudier.
Rendu d'image
Par souci d'exhaustivité, j'ajoute le code C en purée pour créer l'image ci-dessus. displayet convertfont partie d' ImageMagick .
Exemple d'utilisation:
$ ./fntsampler t.fnt hello a
## ### ###
## ## ##
## ## ##
## ### ##### ## ## #####
## ## ## ## ## ## ## ## ##
#### #### ### ## ## ## ##
### ####### ## ## ## ##
## #### ## ## ## ##
## #### ## ## ## ## ##
## ## ###### ## ## #####
$ ./fntsampler t.fnt "Hello World!" > hello.pbm
$ display hello.pbm
L'image d'exemple de toutes les polices ci-dessus a été créée par:
$ for f in *.fnt; do ./fntsampler "$f" "$(printf "%-6s Hello ABC abc 123" "$f")" | convert - "${f%.*}.png"; done
$ convert -negate -append *.png collection.png
Code:
#include <stdio.h>
#include <errno.h>
#include <string.h>
int usage(char *me, char *s)
{
fprintf(stderr,
"Usage: %s <RAW-font-file> \"<string>\" [format] [[invert] | [dot] [blank]]\n\n"
" format p : PBM image (default).\n"
" a : ASCII.\n"
" invert i : invert b/w in PBM.\n"
" dot\n"
" blank : Dot / blank in ASCII mode.\n\n"
"%s\n"
,
me, errno ? "" : s
);
if (errno)
perror(s);
return 1;
}
int main(int argc, char *argv[])
{
char *me = argv[0];
char buf[4096];
size_t n;
char *p;
int i, j, k;
FILE *fh;
char *s;
char fmt = 'p', dot = '1', blank = '0';
if (argc < 3)
return usage(me, "Missing argument(s)");
if (!(fh = fopen(argv[1], "r")))
return usage(me, "Unable to open file");
if ((fread(buf, 1, 4096, fh) != 4096))
return usage(me, "Bad file size");
s = argv[2];
if ((n = strlen(s)) < 1)
return usage(me, "Empty string");
if (argc > 3)
fmt = argv[3][0];
if (fmt != 'a' && fmt != 'p')
return usage(me, "Unknown format");
if (fmt == 'a') {
dot = argc > 4 ? argv[4][0] : '#';
blank = argc > 5 ? argv[5][0] : ' ';
} else {
if (argc > 4 && argv[4][0] == 'i') {
dot = '0';
blank = '1';
}
printf("P1\n");
printf("#Text: \"%s\", using %s\n", s, argv[1]);
printf("%u 16\n", n * 8);
}
for (i = 0; i < 16; ++i) {
for (j = 0; j < (int)n; ++j) {
p = buf + (s[j] * 16) + i;
for (k = 7; k >= 0; --k) {
putchar((*p >> k) & 0x01 ? dot : blank);
}
/*putchar(' '); */
}
putchar('\n');
}
return 0;
}