Discussion :

[sebaaas]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[N_BaH]

Bonjour,

je suis surpris que le code fonctionne, car bash ne sait pas traiter les nombres décimaux.

[disedorgue]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Jipété]

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...

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...

[sebaaas]

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

J'ai changUé :-)

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

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 )

[BufferBob]

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

[disedorgue]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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";
}

[BufferBob]

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

@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

[Flodelarab]

Bonjour

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 ...

[BufferBob]

salut,

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.

[Jipété]

'lut,

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 ?