Pour l’utiliser, c’est très simple :

optipng image.png

Très pratique pour les captures d’écran que l’on veut poster sur les forums.

Voici un exemple de résultat :

$ optipng screenshot.png
OptiPNG 0.5.5: Advanced PNG optimizer.
Copyright (C) 2001-2007 Cosmin Truta.

** Processing: screenshot.png
1196x688 8-bit RGB-alpha non-interlaced
The image is losslessly reduced to 8-bit RGB
Input IDAT size = 117762 bytes
Input file size = 118005 bytes
Trying...
  zc = 9  zm = 8  zs = 0  f = 0  IDAT size = 81686
  zc = 9  zm = 8  zs = 1  f = 0  IDAT too big
  zc = 1  zm = 8  zs = 2  f = 0  IDAT too big
  zc = 9  zm = 8  zs = 3  f = 0  IDAT too big
  zc = 9  zm = 8  zs = 0  f = 5  IDAT too big
  zc = 9  zm = 8  zs = 1  f = 5  IDAT too big
  zc = 1  zm = 8  zs = 2  f = 5  IDAT too big
  zc = 9  zm = 8  zs = 3  f = 5  IDAT too big

Selecting parameters:
  zc = 9  zm = 8  zs = 0  f = 0  IDAT size = 81686

Output IDAT size = 81686 bytes (36076 bytes decrease)
Output file size = 81761 bytes (36244 bytes = 30.71% decrease)

Un peu plus de 30% de gain, ça n’est pas négligeable.

Et pour en faire un script nautilus, mettez ce script dans ~/.gnome2/nautilus-scripts/optipng que vous rendez exécutable :

#!/bin/sh
# Optimizes PNG files.
#
# 30th august 2008 - Romain Vimont (®om)
#

# Use only n as field separator
IFS='
'

# Calls optipng with all args
optipng $NAUTILUS_SCRIPT_SELECTED_FILE_PATHS

Combiné avec imagup, c’est très pratique pour poster des captures d’écran sur un forum.

Voici comment l’utiliser :

imagup monimage.jpg

Les extensions jpg, jpeg, png et gif sont autorisées.

Voici un exemple de résultat :

$ imagup rom-avatar.png
% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                               Dload  Upload   Total   Spent    Left  Speed
100 28706    0 14129  100 14577   3638   3754  0:00:03  0:00:03 --:--:--  5059
rom-avatar.png : http://uploads.imagup.com/05/1220023287_rom-avatar.png

Il est possible d’uploader plusieurs images en une seule ligne :

imagup image1.png image2.jpg

Avec l’option -open, une fois l’image uploadée, elle est ouverte dans le navigateur par défaut.

curl doit être installé.

Voici le script :

#!/bin/sh
# IMAGUP script
#
# 29th august 2008 - Romain Vimont (®om)
#
# Uploads images to www.imagup.com, and returns the http:// link.
#
# Syntax:
#   imagup [-open] fichier1 [fichier2 [...]]
#
# If -open is specified, the link is opened in the default associated program
# (the default browser).
#

# Syntax error detected
# Exits the program with return code 1.
syntax_error() {
    printf '%sn' "Syntaxe : $0 [-open] fichier1 [fichier2 [...]]" >&2
    exit 1
}

# Bad extension detected. Prints messages on stderr.
#
# $1: bad extension
bad_extension() {
    local extension="$1"
    printf '%sn' "Extension not supported: $extension" >&2
    printf '%sn' "Must be one of {png, jpg, jpeg, gif}." >&2
}

# Returns the canonical name of the file, from its (full) path.
#
# $1: (full) path of the file
# return: canonical name of the file
#
# example: get_filename 'a/b.c/d.e.f.jpg' returns 'd.e.f.jpg'
get_filename() {
    local path="$1"
    printf %s "$path" | grep -o '[^/]+$'
}

# Returns the radical of a filename (its name without the extension), from its
# (full) path.
#
# $1: (full) path of the file
# return: radical of the file
#
# example: get_radical 'a/b.c/d.e.f.jpg' returns 'd.e.f'
get_radical() {
    local path="$1"
    local filename="$(get_filename "$path")"
    printf %s "$filename" | sed 's/.[^.]*$//'
}

# Returns the extension of a file, from its (full) path.
#
# $1: (full) path of the file
# return: extension of the file
#
# example: get_extension 'a/b.c/d.e.f.jpg' returns 'jpg'
get_extension() {
    local path="$1"
    local filename="$(get_filename "$path")"
    printf %s "$filename" | grep -o '[^.]+$'
}

# Converts a String to lower case.
#
# $1: input text
# return: lower cased text
#
# example: to_lower_case 'AbCdE' returns 'abcde'
to_lower_case() {
    local text="$1"
    printf %s "$text" | tr -s [A-Z] [a-z]
}

# error when no arguments
[ $# -ge 1 ] || syntax_error

if [ "$1" = '-open' ]
then
    # -open is enabled
    open=true
    shift
    # should remain other arguments
    [ $# -ge 1 ] || syntax_error
fi

# for each argument (a file to upload)
for path
do
    extension=$(get_extension "$path")
    ext=$(to_lower_case "$extension")
    # extention must be one of {png, jpg, jpeg, gif}
    if [ "$ext" = png -o "$ext" = jpg -o "$ext" = jpeg -o "$ext" = gif ]
    then
        filename=$(get_filename "$path")
        radical=$(get_radical "$path")
        # uploads and gets the url back
        url=$(curl www.imagup.com -F
          "fichier=@$path;filename=$radical.$ext;type=image/$ext" |
        grep image-upload |
        grep -o "http://[[:alpha:]]+.imagup.com/[^"]+.(png|jpg|jpeg|gif)")
        if [ "$url" ]
        then
            # if it worked, prints the url
            printf '%sn' "$path : $url"
            # if -open is selected, open-it in the default application
            [ $open ] && xdg-open "$url"
        else
            # it didn't work
            printf '%sn' "Problem while uploading $path" >&2
        fi
    else
        # file extension is bad
        bad_extension "$extension"
    fi
done

Pour l’installer, copiez-le dans un fichier /usr/bin/imagup que vous rendez exécutable :

gksudo gedit /usr/bin/imagup

Faites un copier-coller du script, sauvez-le. Puis :

sudo chmod 755 /usr/bin/imagup

Une fois installé, vous pouvez également l’utiliser comme script nautilus. Mettez le script suivant dans ~/.gnome2/nautilus-script/imagup-wrapper et rendez-le exécutable :

#!/bin/sh
# nautilus IMAGUP script wrapper
#
# 29th august 2008 - Romain Vimont (®om)
#
# Needs "imagup" core script to be installed.
#

# Use only n as field separator
IFS='
'

# Calls imagup with all args
imagup -open $NAUTILUS_SCRIPT_SELECTED_FILE_PATHS

Ensuite, dans nautilus, il est possible d’envoyer l’image en cliquant sur Script → imagup-wrapper. Les images ainsi envoyées s’ouvriront dans le navigateur par défaut.

Cependant, en écrivant ce script, je me suis aperçu de trois problèmes dans nautilus : un problème de proxy, un problème de vue liste et un problème avec le lancement de scripts à partir du bureau.

Les deux derniers problèmes sont contournés avec le script imagup-wrapper (le dernier script).

Si, au lieu d’appeler une fois imagup avec tous les arguments, on voulait l’appeler n fois avec un seul argument (utile lorsque le programme appeler ne boucle pas sur les arguments), on aurait pu utiliser :

printf %s "$NAUTILUS_SCRIPT_SELECTED_FILE_PATHS" |
while read -r arg
do
    imagup -open "$arg"
done

ou encore :

IFS='
'
for arg in $NAUTILUS_SCRIPT_SELECTED_FILE_PATHS
do
    imagup -open "$arg"
done

J’en ai profité pour écrire une section les pièges à éviter sur la doc ubuntu-fr de nautilus-scripts.

• fin
• normal
• économique

Mais lorsque l’on choisit un réglage, les photos font à peu près toutes la même taille, qu’elles soient simples ou complexes. Par exemple, en réglage fin, leur taille est quasiment toujours comprise entre 2,8Mio et 2,9Mio.

Or, une photo uniforme devrait prendre beaucoup moins de place qu’une photo très complexe, avec beaucoup de contours.

D’ailleurs, on s’en rend compte lorsqu’on recompresse ces photos sur un ordinateur :

Sur cette capture d’écran, les photos contenues à la racine (les 5 dernières) sont les photos originales, prises par l’appareil photo.
Les photos contenues dans les répertoires convertXX sont les photos converties avec :

convert image.jpg -quality XX convertXX/image.jpg

(imagemagick doit être installé)

On se rend compte que les photos ont une taille beaucoup plus variable, ce qui est une bonne chose. Sur l’ensemble de mes albums, j’ai des photos à 500Kio et d’autres à 1,8Mio : c’est la qualité finale de la photo qui est prise en compte, et non la taille à atteindre.

J’ai donc décidé de prendre les photos en qualité maximale sur l’appareil photo, et de les recompresser à l’importation.

J’utilise digiKam pour gérer mes photos, qui possède une fonctionnalité pour recompresser les photos (utilisant exacement le même algorithme que imagemagick).

Le problème, c’est que je veux éviter, par inattention, de recompresser plusieurs fois les mêmes photos (perte de qualité inutile). Par exemple, lorsqu’on importe les photos d’une carte mémoire, qu’on les recompresse, puis qu’on importe les photos d’une seconde carte mémoire, difficile de différencier les photos déjà recompressées des autres (pour les photos se trouvant dans le même dossier).

J’ai donc écrit un petit script, qui garde dans un fichier la liste des photos déjà recompressées, et qui compresse toutes celles qui ne sont pas présentes dans le fichier.

Ainsi, après une importation de photos, j’exécute le script, seules les nouvelles seront recompressés.

#!/bin/sh
#
# Mogrifie tous les fichiers jpeg non encore mogrifiés (recompressés en jpeg)
#

# le fichier "mogrified" doit exister, si ce n'est pas le cas, faire
# touch mogrified" avant de lancer le script
if [ ! -f mogrified ]
then
    echo 'mogrified file not found.'
    exit 1
fi

# liste tous les fichiers .jpg dans les répertoires décrivant une année
# (2005, 2006...)
find -iname '*.jpg' | grep ^./20 | sort > filelist &&

# supprime de cette liste tous les fichiers déjà mogrifiés
comm -23 filelist mogrified |
while read photo
do
    # mogrifie ces fichiers
    echo "$photo"
    mogrify -quality 90 "$photo"
done

# les fichiers mogrifiés sont maintenant les fichiers de la liste complète
mv filelist mogrified

L’outil mogrify fait la même chose que convert, sauf qu’il modifie le fichier sur place (et écrase donc la source).

Cela permet d’avoir un très bon rapport qualité/taille, sans provoquer des pertes visibles sur les photos très complexes, ni utiliser de l’espace inutilement sur les photos simples.

La méthode la plus simple consiste à appuyer sur ImprÉcran.
Cela ouvre une fenêtre dans lequelle on peut choisir la destination :

En appuyant sur Alt+ImprÉcran, il est possible de capturer uniquement la fenêtre active :

Cette méthode est simple, mais elle ne permet pas de faire une sélection arbitraire ni de définir un délai (ce qui empêche donc de faire une capture lorsque le cube est en rotation, ou lorsqu’un menu contextuel est ouvert).

Méthode #2

Cette méthode est en fait la même que la #1, car c’est le même programme qui est lancé (gnome-screenshot), sauf qu’au lieu d’être lancé par ImprÉcran, il est lancé manuellement :

L’avantage, c’est que plus d’options sont disponibles, notamment le délai :

L’option «inclure la bordure de la fenêtre» ne fonctionne que si on n’utilise pas de gestionnaire de bureau composite (compiz).

Méthode #3

Avec Gimp : il suffit de démarrer Gimp, Fichier → Acquisition → Capture d’écran.

Cette fenêtre offre toutes les options intéressantes. La capture effectuée s’ouvre ensuite dans Gimp, il suffit de sauver le fichier. Cette méthode est pratique lorsqu’on veut retourcher la capture (flouter certaines zones…), ou capturer une région de l’écran avec délai (on attend d’abord le délai, puis on sélectionne, ça permet de rendre active la fenêtre qu’on veut pour le screenshot par exemple).
Par contre un inconvénient peut être que Gimp pourrait apparaître à l’écran (dans la barre des tâches), selon la zone capturée.

Méthode #4

C’est la méthode la plus rapide. Elle nécessite compiz et l’activation du plug-in screenshots (dans Extras).
Une fois activé, il suffit de faire toucheWindows+clicGauche pour dessiner un rectangle translucide sur l’écran, et cette zone sera capturée.
L’image sera sauvée dans le répertoire prédéfini, par défaut dans ~/Desktop.
Attention, ce répertoire peut ne pas exister, si par exemple votre bureau se trouve dans ~/Bureau. Pensez donc à changer le répertoire utilisé pour les screenshots.

Voilà, je trouve que c’est utile de connaître toutes ces méthodes, ça permet de choisir celle adaptée selon le cas.

Voici un petit tableau récapitulatif :

   ╭───────┬─────────┬────────────┬───────┬─────────────┬─────────────╮
   │ plein │ fenêtre │ sélection  │ délai │    choix    │   1 ou 2    │
   │ écran │ active  │ arbitraire │       │ destination │ actions max │
╭──┼───────┼─────────┼────────────┼───────┼─────────────┼─────────────┤
│#1│   ✔   │    ✔    │     ✘      │   ✘   │      ✔      │      ✔      │
├──┼───────┼─────────┼────────────┼───────┼─────────────┼─────────────┤
│#2│   ✔   │    ✔    │     ✘      │   ✔   │      ✔      │      ✘      │
├──┼───────┼─────────┼────────────┼───────┼─────────────┼─────────────┤
│#3│   ✔   │    ✔    │     ✔      │   ✔   │      ✔      │      ✘      │
├──┼───────┼─────────┼────────────┼───────┼─────────────┼─────────────┤
│#4│   ✘   │    ✘    │     ✔      │   ✘   │      ✘      │      ✔      │
╰──┴───────┴─────────┴────────────┴───────┴─────────────┴─────────────╯

Vous pouvez maintenant optimiser les images png et les uploader sur un hébergeur pour les poster sur un forum.