Catégorie : linux

Programmer en C la librairie gd : le texte

J’ai décidé de faire un petit article qui explique rapidement comment écrire du texte « non crénelé », donc « antialiasé » du des images, en C, en utilisant la librairie gd.

Tout est très simple : vous trouverez déjà le manuel ici, pas mis à jour mais suffisant et les exemples fonctionnent, ce qui est le plus important.

Ce qui m’a posé le plus de problème, ce n’est pas de demander à écrire du texte. L’exemple ici fonctionne parfaitement, faites un copier coller, hop on y est.
Non, le problème c’est la « région » calculée dans laquelle sera dessiné le texte.
Pour résumer, on demande de pré-calculer la « boîte » dans laquelle sera dessiné le texte (toujours l’exemple ici).
Ce que j’ai mis beaucoup de temps à comprendre, c’est ce que je vais traduire dans « mon » langage : la boîte englobante qui est renvoyée, c’est l’espace qui sera utilisé en fonction du point de référence (x,y) que vous donnez pour dessiner.

Je m’explique. Vous demandez à calculer la boite pour dessiner le texte en passant la variable NULL :

err = gdImageStringFT(NULL,&brect[0],0,f,sz,0.,0,0,s);
if (err) {fprintf(stderr,err); return 1;}

Maintenant, dans brect il y aura ce genre d’informations :


     (   -1,  -57)     ( 1513,  -57)
           +-----------------+
           |                 |
           |                 |
           +-----------------+
     (   -1,   15)     ( 1513,   15)

Et en fait, c’est uniquement des informations pour vous, parce qu’après, lorsque vous lui demanderez de dessiner, il les ignorera : seules les informations x et y seront utilisées :

err = gdImageStringFT(im,&brect[0],black,f,sz,0.0,x,y,s);
if (err) {fprintf(stderr,err); return 1;}

Autrement dit, prenons un exemple : vous voulez dessiner votre texte en x=0. Seulement, le rectangle de retour est celui que j’ai affiché en haut : ça signifie que le dessin va « déborder » de (-1) pixel sur x. Autrement dit, si vous voulez le mettre en 0, il faut donner les coordonnées (x=1). Même chose pour y : les lettres vont « s’étaler » 57 pixels au dessus, et 15 pixels en dessous. Donc si vous voulez écrire le texte en (0,0), il vous faudra passer x=1, y=57.

En relisant ça parait facile, mais ça ne l’a pas été pour moi !
En espérant que cela serve à quelqu’un un jour…

Linux et Applications Windows : ça marche !

Je suis tout simplement impressionné.
En quelques clicks d’installation, j’ai installé « Wine ».
Tout a fonctionné du premier coup.
J’ai copié collé le répertoire dans lequel tournait notre application de téléphonie :
Et voilà le résultat :
Image petite du logiciel Windows sous Linux
Ça fonctionné du premier coup !
Je suis vraiment impressionné.
Donc, pour l’instant, tant que je n’ai pas besoin de fonctionnalités particulières, je reste sous Linux.
Je dois avouer que le seul programme qui me manque c’est Photoshop.
Pour tout le reste, je m’en passe allègrement !

Quand je clique sur arrêter pour arrêter le PC, c’est simple :

  • sous Windows, il met montre en main plus d’une minute, et encore… je ne suis même pas sûr qu’il s’arrête pour la simple et bonne raison qu’il y a des tonnes de programmes : un anti virus, un anti spam, le logiciel de téléphonie qui ne veut quitter sous aucun prétexte, le logiciel d’archivage, etc. et des fois ils se gênent tous entre eux ;
  • sous Linux, ça met 4 secondes montre en main, c’est véridique !

Uzbl : un browser Web entièrement en ligne de commande !

C’est ici que vous pourrez voir cet « ovni » du monde Internet : http://www.uzbl.org/.

Il est en plusieurs parties : le coeur même du système, et un programme qui interagit avec lui, lui envoie des messages, et affiche son résultat de retour. Comme le coeur semble extrêmement bien fait, on est censé pouvoir faire tout un tas de choses, automatiquement : un cas concret, c’est l’exemple du second programme qui interagit avec le coeur : en pratique on a un navigateur. Et puis il a rajouté une troisième couche, un troisième programme qui interagit avec le second, et qui donne la possibilité de tout gérer par onglets. Comme tout est open source, et apparemment très bien écrit, il est possible de faire plein de choses.

Le second programme, il a décidé de faire en sorte que son comportement soit du style « vi », à savoir : tout se fait au clavier, il y a un mode « navigation » où les touches se comportement d’une certaine façon, et il y a le mode édition (touche « i » comme sur vi, pour les connaisseurs), où on peut entrer des informations dans les formulaires.

Dans la vidéo, sur le site, on voit qu’il va déjà bien plus vite en tapant sur son clavier qu’en utilisant la souris. Je pense que lorsqu’on va toujours sur des sites qu’on connait bien, on doit au final gagner beaucoup de temps.

Linux : exemple php pratique pour grep, awk, sort, uniq et xargs

Ci-suivent quelques étapes qui expliquent l’utilisation des outils grep, awk, sort et uniq. C’est juste un exemple concret et pratique, n’imaginez pas un truc immense ! J’espère que cela vous donnera des idées, si un jour vous avez besoin de faire quelque chose dans le genre.

Objectif : lister tous les fichiers php du répertoire courant, qui font appel à l’ordre « date() ».

Donc :

  • Ordre « find » de Linux qui liste tous les fichiers d’un répertoire et de ses sous-répertoires :
    >find .
    ./robots.txt
    ./tarification2.php
    ./partenaire_demande.php
    ./img
    ./img/menu-gb_02-Carte-image_02_o.gif
    ./img/fleche_blc_fond_bleu.gif
    ./img/old_get_adobe_reader.gif
    ./img/menu-gb_02-Carte-image_05_o.gif
    ./img/ste_gestion_over.gif
    ./img/cbp_attest_ass_over.gif
    ./img/index_06.jpg
    [etc. etc.]
  • Ordre « grep » de Linux qui ne prend que les fichiers « qui se terminent par php » :
    >find . | grep php$
    ./img/index.php
    ./aore/verlogin.php
    ./aore/tarication2.php
    ./aore/img/iex.php
    ./aore/corats.php
    ./aore/ind.php
    ./aore/ccts.php
    [etc. etc.]
  • Ordre « xargs » de Linux qui dit « je vais te donner un programme (ici « grep »), et tu lui fais suivre ligne par ligne les résultats. Pour la note, « grep 'date(' [nom_de_fichier] » vérifie si dans le fichier [nom_de_fichier], il y a ‘date(‘ :
    >find . | grep php$ | xargs grep 'date('
    ./pe.php: $date=date("Y-m-d H:i:s");
    ./partde.php: $date_french=date("d-m-Y H:i:s");
    ./as/vergin.php:$date=date("Y-m-d H:i:s");
    ./as/cs.php:$date=date("Y-m-d H:i:s");
    ./as/cs.php:$date=date("Y-m-d H:i:s");
    ./as/cs.php: $date=date("d-m-Y H:i:s");
    ./as/sis.php:$date=date("Y-m-d H:i:s");
    ./ae/sis.php:$date=date("Y-m-d H:i:s");
    ./ae/stre_cle.php:$date_heure = date("Y-m-d H:i:s");
    ./ae/stre_cle.php:$date = date("Y-m-d");
    [etc. etc.]
  • Ordre « awk » qui prend la ligne en cours, considère que les « : » sont les séparateurs (-F:), et n’affiche en sortie que le premier enregistrement ('{print $1}') pour chaque ligne :
    >find . | grep php$ | xargs grep 'date(' | awk -F: '{print $1}'
    ./re/vein.php
    ./re/ctrs.php
    ./re/ctrs.php
    ./re/ctts.php
    ./re/sises.php
    ./re/sires.php
    ./re/sire_cle.php
    ./re/sire_cle.php
    ./re/sire_cle.php
    ./re/sire_cle.php
    ./ae/mu.php
    ./ae/mu.php
    [etc. etc.]
  • Ordre « uniq » qui prend la totalité de ce qu’on lui passe, et supprime les doublons :
    >find . | grep php$ | xargs grep 'date(' | awk -F: '{print $1}' | uniq
    ./re/vein.php
    ./re/ctrs.php
    ./re/ctts.php
    ./re/sises.php
    ./re/sires.php
    ./re/sire_cle.php
    ./ae/mu.php
    [etc. etc.]
  • Ordre « sort » qui trie par ordre alphabétique :
    >find . | grep php$ | xargs grep 'date(' | awk -F: '{print $1}' | uniq | sort
    ./ae/mu.php
    ./re/ctrs.php
    ./re/ctts.php
    ./re/sises.php
    ./re/sires.php
    ./re/sire_cle.php
    ./re/vein.php
    [etc. etc.]

Et voilà ! Une minute pour taper cette commande, et on a la liste de tous les fichiers à vérifier pour être certain qu’il n’y aura plus de warnings() lors de l’utilisation de date() dans ces fichiers php.
Pour la note, j’ai eu besoin de faire ça parce que ces fichiers devaient avoir en tête l’initialisation préalable date_default_timezone_set(). Ces fichiers sont les fichiers d’un très vieux site qu’il faut faire fonctionner en mettant au minimum les mains dedans, c’est ce que j’ai tenté de faire (pour préserver aussi ma santé mentale).

(Update 6 février 2011)
Sur ce site ici qui me cite, il y a une réponse très intéressante : lorsqu’on connait bien l’ordre « find« , on peut résumer tout mon article en une seule ligne et un seul ordre :

find -iname "*.php" -exec grep "\Wdate(" "{}" \; -print

Bon, le résultat ne renvoie pas que les fichiers, mais il est bien formaté, c’est aussi très pratique. Voici un exemple de sortie de cet ordre :

  $debloc_jj = (int) date('d');
  $debloc_mm = (int) date('m');
  $debloc_aa = (int) date('Y');
  echo '<li>Lancement des calculs à '.date("H:i:s").'.</li>';
  echo '<li>Terminé à '.date("H:i:s").'.</li>';
./_tests_unitaires/tarifs_generali/tarifs_2010.php
  $debloc_jj = (int) date('d');
  $debloc_mm = (int) date('m');
  $debloc_aa = (int) date('Y');
./_tests_unitaires/verifs.php
  $debloc_jj = (int) date('d');
  $debloc_mm = (int) date('m');
  $debloc_aa = (int) date('Y');
./_tests_unitaires/verifs_multi.php

Vim : aide et exemples excellents

Voici un site qui, si vous parlez Anglais, va vous faire gagner un temps fou :
http://vimcasts.org/
Ce sont des vidéos explicatives sur le fonctionnement de vim, avec toutes les options et surtout, pourquoi vim vous fait gagner du temps.

Ici aussi, si vous parlez Anglais, ce document explique pour les développeurs, comment gagner un temps fou avec vim.

Equivalent dos2unix

Sous Linux/Unix, Si vous cherchez à transformer un texte DOS (va de retro Satanas) en texte Unix, voici une solution rapide et efficace :

awk '{sub(/\r$/,"");print}' nom_fichier_dos > nom_fichier_unix
ou bien encore :
sed 's/.$//' nom_fichier_dos > nom_fichier_unix

Cette petite explication a été honteusement pompée ici, le but principal étant d’aider ceux qui ont du mal avec l’Anglais.

Vim : mémo pour des ordres simples

Je vais ici mettre toutes les astuces au fur et à mesure que je les découvre :

Le fichier de configuration personnalisé par rapport à l’utilisateur connecté est :
~/.vimrc

Directement sous vim comment éditer le fichier de configuration :
:e $MYVIMRC

Pour mettre des espaces au lieu de tabulations :
set expandtab

Pour dire à combien d’espaces à insérer lorsqu’on appuie sur Tab :
set tabstop=2

Les macros :

  • Commencer l’enregistrement :
    q[lettre]
  • Terminer l’enregistrement :
    q
  • Rejouer une macro :
    @[lettre]

Directement sous vim comment éditer un fichier de coloration syntaxique :
:e $VIMRUNTIME/syntax/

Tiré de l’aide et ré-expliqué à ma sauce :

  • Donner un ordre uniquement applicable sur le fichier en cours :
    setlocal [ordre]
  • Aller à la ligne automatiquement si la taille dépasse 78 caractères :
    textwidth=78
  • Appliquer un ordre que si le fichier est de type « text » :
    autocmd FileType text [ordre]
  • Mélange des 3 précédents points :
    autocmd FileType text setlocal textwidth=78
    Explication : dès que le fichier est de type « text », appliquer uniquement sur ce fichier cet ordre : aller à la ligne automatiquement si la taille dépasse 78 caractères.

Lancer une commande shell sans quitter vim :
:![commande shell]

Lancer un commande shell sans quitter vim :
:sh
(puis quand vous avez fini, quitter le shell via Ctrl-d ou l’ordre « exit ») et vous revenez sous vim !

Si vous avez d’autres suggestions surtout n’hésitez pas !

Apache : développement C et tutoriaux apr

Mes petits articles vont peut être me rendre célèbre.
Enfin chez les geeks. Et les asiatiques (les deux pages sur lesquelles je suis cité sont en Japonais)

Voilà la réponse du type qui a fait les exemples les plus pratiques, question « tutoriaux apr » :

Hi,

Sorry for the late reply.

I appreciate what you’ve done.

I put the links on the following pages (the former is written in Japanese).

http://dev.ariel-networks.com/column/tech/libarp_tutorial/
http://dev.ariel-networks.com/apr/

Thanks again.

Linux Cron : mémo rapide / exemples concrets

Bon, pour tous ceux qui veulent utiliser cron, voici comment il fonctionne (c’est souvent le plus difficile à comprendre).

Toutes les minutes, le système vérifie s’il faut qu’il lance un programme. Comment fait-il sa vérification ?
C’est simple : il prend date + heure du moment et la décompose.
Prenons aujourd’hui et maintenant :

Samedi 27 février 2010, 1h44 du matin

Cela va être décomposé ainsi :

Minutes / Heures / Jour / Mois / Jour de la semaine
44      / 01     / 27   / 02   / 6

Et le système va lister toutes les tâches, et si les chiffres sont identiques, alors il l’exécute.
Exemple :

* * * * * root ping -c 1 google.fr > /dev/null

Le «*» signifie : «quelque que soit le chiffre, c’est valide».
Comparaison :

Minutes / Heures / Jour / Mois / Jour de la semaine
44      / 01     / 27   / 02   / 6
*       / *      / *    / *    / *

Tout correspond => exécution de la tâche !
Maintenant, des exemples qui vont vous servir :

# m h dom mon dow user  command
17 *  * * * root    [commande]

Lancer la commande toutes les fois où «minutes = 17» => lancer «[commande]» toutes les heures (00:17, 01:17, 02:17, 03:17 etc.).

# m h dom mon dow user  command
25 6  * * * root    [commande]

Lancer la commande toutes les fois où «minutes = 17» et «heure = 6» => lancer «[commande]» tous les jours à 6:17.

# m h dom mon dow user  command
47 6  * * 7 root    [commande]

Lancer la commande toutes les fois où «minutes = 47, heure = 6» et «jour de la semaine = 7» => lancer «[commande]» tous les dimanches à 6:47.

# m h dom mon dow user  command
52 6  1 * * root    [commande]

Lancer la commande toutes les fois où «minutes = 52, heure = 6» et «jour du mois = 1» => lancer «[commande]» tous premiers du mois à 6:52.

Un peu plus complexe mais plus pratique : on peut préciser des intervalles : «2-6» veut dire «de 2 à 6 inclus». Exemple :

# m h dom mon dow user  command
* 1-6 * * * root    [commande]

Lancer la commande toutes les fois où «heure est comprise entre 1 et 6» => lancer «[commande]» toutes les minutes, de une heure à six heures du matin (c’est un exemple concret puisque «[commande], c’est une commande d’une araignée Internet (spider) qui va vérifier des choses pendant que tout le monde dort).

Un peu plus complexe mais encore plus pratique : on peut préciser des intervalles : «*/4» veut dire «tous les multiples de 4». Exemple :

# m h dom mon dow user  command
*/4 1-6 * * * root    [commande]

Lancer la commande toutes les fois où «heure est comprise entre 1 et 6» et «la minute est un multiple de 4» => lancer «[commande]» toutes les quatre minutes, de une heure à six heures du matin (c’est un exemple concret puisque «[commande]», c’est une commande d’une araignée Internet (spider) qui va vérifier des choses pendant que tout le monde dort).

PS : oui oui il est bien 1:44 du matin et je n’arrive pas à dormir…

Vim : comment changer les couleurs sur Linux

Sur Linux en ligne de commandes il vous faut lister toutes les colorations possibles :
C’est simple tapez l’ordre « locate koehler » comme ceci :
# locate koehler
/usr/share/vim/vim70/colors/koehler.vim
#

Et vous aurez la réponse qui vous dit où se trouve le fichier de coloration appelé « koehler »
C’est là que se trouvent tous les fichiers. Donc dans notre cas c’est dans :
/usr/share/vim/vim70/colors/
Il suffit de faire un listing de toutes les colorations disponibles :
~# ls -1 /usr/share/vim/vim70/colors/
blue.vim
darkblue.vim
default.vim
delek.vim
desert.vim
elflord.vim
evening.vim
koehler.vim
morning.vim
murphy.vim
pablo.vim
peachpuff.vim
README.txt
ron.vim
shine.vim
slate.vim
torte.vim
zellner.vim
~#

Ensuite éditez votre fichier de configuration personnel (celui que vim lit et applique lorsque vous le lancez) :
vim ~/.vimrc

Et ajoutez-y à la fin une coloration. Moi j’aime bien zellner.vim :
colorscheme zellner

Sauvez le fichier puis éditez n’importe quel fichier et vous verrez que la coloration a changé.