Optimiser ou changer de langage

Version imprimable

Bonjour à tous,

J'ai réaliser (enfin j'ai plutôt compiler les infos) un petit script avec un hash perceptuelle (Dhash) afin de reconnaitre si une image est semblable à une autre.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#!/bin/bash
#passage des variables en dehors de la boucle while
shopt -s lastpipe
#recherche des images dans le répertoire
for image in /tmp/seb/deux/test/*
        do
#initialisation des variables
        hash=""
        i=0
#convertir l'image et récupérer la couleur
        convert "$image" -resize 9X8\! -colorspace Gray txt:- |
        tail -n +2 | tr -cs '0-9.\n'  ' ' |
                while read x y r g junk; do
#algorythme DHASH
                        case $i in
                                "0") precedent=$r
                                ((i++));;
                                [1-7]) if [ "$precedent" -gt "$r" ]
                                                then hash=$hash"1"
                                                else hash=$hash"0"
                                        fi
                                        precedent=$r
                                        ((i++));;
                                "8") if [ "$precedent" -gt "$r" ]
                                                then hash=$hash"1"
                                                else hash=$hash"0"
                                        fi
                                        i=0;;
                        esac
                done
#calcul de la distance de Hamming entre 2 images
distance=0
left=$hash
#image à comparer à :
right="0101110100000000010110000000000000000000000000000000000000000001"
for ((j=0; j<${#left}; j++));do
        [[ "${left:j:1}" == "${right:j:1}"  ]] || (( "distance++"))
done
echo "difference est ${distance}"
done

Le code fonctionne mais j'ai un problème de performance. Pour analyser 2800 images (qui se trouvent en mémoire vive "/tmp/ ..." ) cela me prend +/- 1m20 soit 35 images à la seconde.

Y-a-t-il moyen optimiser cela ou dois-je changer de langage de programmation? Lequel? Le but étant que ce petit script soit le plus rapide possible.

Bonne soirée

22/12/2017, 23h12
N_BaH

Bonjour,

je suis surpris que le code fonctionne, car bash ne sait pas traiter les nombres décimaux.
22/12/2017, 23h30
disedorgue

Bonjour,

Non, il ne traite que des entiers, mais déjà convert semble lent, faudrait déjà juste faire la boucle:

Code:

time { for image in /tmp/seb/deux/test/* ; do convert "$image" -resize 9X8\! -colorspace Gray txt:/dev/null ; done ; }

Et voir le temps que ça dure.
23/12/2017, 00h50
Jipété

Citation:

Envoyé par sebaaas

Pour analyser 2800 images (qui se trouvent en mémoire vive "/tmp/ ..." ) cela me prend +/- 1m20 soit 35 images à la seconde.

Y-a-t-il moyen optimiser cela ou dois-je changer de langage de programmation ? Lequel ? Le but étant que ce petit script soit le plus rapide possible.

Dans ma machine il y a des images qui pèsent quelques ko et d'autres plusieurs centaines de Mo. Partant de là, tu comprends instantanément (enfin, j'espère) qu'il est absolument impossible de répondre à ces questions...

Citation:

Envoyé par sebaaas

Optimiser ou changer de language

Tiens, ça me fait penser qu'il faudra que je passe au guarage, j'ai un bruit bizarre dans ma bagnole...
23/12/2017, 07h48
BufferBob

salut,

Citation:

Envoyé par sebaaas

Y-a-t-il moyen optimiser cela ou dois-je changer de langage de programmation?

les deux mon capitaine, il y a très certainement moyen d'optimiser, mais tu ne transformeras pas un veau en cheval de course, et si tu as besoin d'aller vite bash est un choix exécrable

par ailleurs tu fais de drôles de manips, à savoir finalement pour chaque image (donc à minima 35x par seconde) invoquer convert pour transformer une image en sa représentation textuelle, pour au final lire les informations de chaque pixel ligne par ligne, utiliser un langage qui à la fois permet de manipuler des images directement et au niveau pixels me semblerait déjà une optimisation intéressante (à voir...)

Python est à mon sens une alternative de choix, avis perso.
23/12/2017, 09h13
Jipété

'lut,

Citation:

Envoyé par BufferBob

utiliser un langage qui à la fois permet de manipuler des images directement et au niveau pixels me semblerait déjà une optimisation intéressante (à voir...)

Python est à mon sens une alternative de choix, avis perso.

En Pascal il y a les accès bas niveau par pointeur avec Scanline (en Delphi -- avec Lazarus ça s'appelle GetLineStart) , ça existe en Python ?
23/12/2017, 09h53
sebaaas

Citation:

Envoyé par Jipété

Tiens, ça me fait penser qu'il faudra que je passe au guarage, j'ai un bruit bizarre dans ma bagnole...

J'ai changUé :-)

Citation:

Envoyé par disedorgue

Bonjour,

Non, il ne traite que des entiers, mais déjà convert semble lent, faudrait déjà juste faire la boucle:

Code:

time { for image in /tmp/seb/deux/test/* ; do convert "$image" -resize 9X8\! -colorspace Gray txt:/dev/null ; done ; }

Et voir le temps que ça dure.

1 minute mon capitaine, mais la machine était à froid.

Citation:

Envoyé par Jipété

Dans ma machine il y a des images qui pèsent quelques ko et d'autres plusieurs centaines de Mo. Partant de là, tu comprends instantanément (enfin, j'espère) qu'il est absolument impossible de répondre à ces questions..

Les images font toujours la même taille : 1,18 méga (une image BMP de 720 x 576 )
23/12/2017, 12h52
BufferBob

Citation:

Envoyé par Jipété

En Pascal il y a les accès bas niveau par pointeur avec Scanline (en Delphi -- avec Lazarus ça s'appelle GetLineStart) , ça existe en Python ?

difficile à dire (ça a quand même l'air d'un truc très spécifique), mais pour le dire simplement entre Pillow, Numpy, SciPy et autres OpenCV y'a beaucoup de choses qui existent en Python propres à optimiser drastiquement à la fois la longueur du code et sa vitesse d'exécution tout en restant très simple à coder, c'est probablement ce qui fait son succès actuel dans les milieux scientifiques et les domaines comme le traitement d'images et le machine learning, là il me semble qu'avec la distance de Hamming appliquée pour trouver les similarités entre deux images on est plus très loin d'une classification

Voici un code certainement plus rapide que ton script en shell, mais ce qui est coûteux, c'est la transformation de l'image, donc le gain ne doit pas être énorme.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#!/usr/bin/env perl
 
use strict;
use warnings;
use Image::Magick;
my @tabfile=glob("*.bmp");
my @right=(0,1,0,1,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1);
for (@tabfile) {
	my $image=Image::Magick->new();
	$image->Read($_);
	$image->Resize("9x8\!");
	$image->Colorspace("Gray");
	my @left;
	for my $j (0..7) {
		my $c=0;
		(my $pre , my @sd)=grep { $c++%3==0 } $image->GetPixels(y=>$j);
		push @left,map { $c=$pre ; $pre=$_ ; $c > $_ ? "1" : "0" } @sd;
	}
	my $c=0;
	for my $i (0..63) { $left[$i] == $right[$i] || $c++ }
 
	print "Pour $_ la Différence est $c\n";
}

26/12/2017, 10h49
BufferBob

@disedorgue, :plusser: pour l'effort (motivé de noël :lol:)

@sebaaas, juste par curiosité, c'est vraiment pertinent une image de 8x8 grayscale issue d'une image en couleurs de taille non-spécifiée (présumée beaucoup plus grande) ? j'imagine que l'algorithme de redimensionnement lui-même doit avoir un impact assez important sur la miniature finale. est-ce qu'il y a moyen d'avoir un lot d'images tests variées et leurs miniatures respectives stp ?

ps: bonnes fêtes de fin d'années à vous tous
30/12/2017, 17h26
Flodelarab

Bonjour :coucou:

Ne serait-ce pas le principe des empreintes ?
Empreintes de fichier ou empreintes digitales.
A partir d'une empreinte, on peut distinguer 2 specimens mais on ne peut pas refabriquer les specimens à partir de leurs empreintes.
Il suffit d'utiliser une fonction irréversible pertinente.
Voilà pourquoi il ne faut pas dire que les mots de passe sont chiffrés. On calcule juste une empreinte ...
30/12/2017, 21h54
BufferBob

salut, ça faisait longtemps :)

Citation:

Ne serait-ce pas le principe des empreintes ?

je vois ce que tu veux dire, mais avec la fonction de hashage l'intérêt c'est justement l'unicité -au moins théorique- de l'empreinte, là il s'agit non seulement juste d'un redimensionnement de l'image mais en plus on a aucune idée de la méthode utilisée (à part qu'il faut regarder du coté d'ImageMagick) comme si ça n'avait finalement pas d'incidence

on peut facilement imaginer que 2 images pourtant très différentes à l'origine, une fois redimensionnées en 8x8 et passées en niveaux de gris peuvent être parfaitement identiques, alors qu'avec un redimensionnement en 32x32 ou 64x64 on aurait moins de chances de se tromper par exemple

pour autant je sais qu'en pratique c'est courant de faire ce genre de manip (pour faire de la détection ou de la reconnaissance de formes par exemple), c'est pour ça que je posais la question, et dans le principe t'as sûrement raison au final, c'est surtout que j'ai du mal à me le représenter :roll:
31/12/2017, 11h24
disedorgue

Moi, ce que j'en comprend, c'est qu'il a une image d'origine dont il a déjà calculé le "hash" (sa variable right), et il calcul ce qu'on appelle la distance de hamming afin de certainement vérifier le taux d'altération entre son image d'origine et les autres.
Mais, à part comparer des dégradés entre images, je n'en vois pas l'interêt... sauf peut-être pour de la compression de suite d'image genre film.
01/01/2018, 23h51
Jipété

1 pièce(s) jointe(s)

Salut, et bonne année à tutti :coucou:

Citation:

Envoyé par disedorgue

Moi, ce que j'en comprend, c'est qu'il a une image d'origine dont il a déjà calculé le "hash" (sa variable right), et il calcule ce qu'on appelle la distance de hamming afin de certainement vérifier le taux d'altération entre son image d'origine et les autres.

Dommage qu'on n'ait plus de nouvelles...

Citation:

Envoyé par BufferBob

on peut facilement imaginer que 2 images pourtant très différentes à l'origine, une fois redimensionnées en 8x8 et passées en niveaux de gris peuvent être parfaitement identiques, alors qu'avec un redimensionnement en 32x32 ou 64x64 on aurait moins de chances de se tromper par exemple.

Oh tu sais, ça dépend vraiment de l'original et des traitements effectués ensuite :
Pièce jointe 338725

En haut un bête dégradé généré par programmation, et dessous la même image convertie en niveaux de gris par The Gimp en choisissant l'option "Clarté".
Ça surprend, hein ! Et je peux vous garantir que j'ai vérifié avec un color-picker, on est bien à 127,127,127 d'un bout à l'autre.
Le dégradé d'origine fait 512 px de large sur 100 de haut, là j'ai tout réduit histoire de pas bouffer tout l'espace disque de dvlp, :mouarf: