comando shell per ottenere la dimensione in pixel di un'immagine

Esiste un comando shell che restituisce la dimensione in pixel di un'immagine?

Sto cercando di produrre una gif animata partendo da gif diverse con dimensioni diverse utilizzando convert(ad esempio convert -delay 50 1.gif 2.gif -loop 0 animated.gif).

Il problema è che la conversione si sovrappone semplicemente alle immagini usando la dimensione della prima immagine come dimensione della gif animata, e poiché hanno dimensioni diverse il risultato è un po 'un casino, con i bit dei vecchi frame mostrati sotto quelli nuovi.

trovato una soluzione identify:, parte del pacchetto imagemagick, fa esattamente quello di cui ho bisogno

$ identify color.jpg 
> color.jpg JPEG 1980x650 1980x650+0+0 8-bit DirectClass 231KB 0.000u 0:00.000

Invece di analizzare l'output di identifyeye, o delle utility di testo, puoi usare la sua -formatopzione per produrre l'ampiezza e l'altezza in qualunque formato tu preferisca. Per esempio:

$ identify -format '%w %h' img.png
100 200
$ identify -format '%wx%h' img.png
100x200

In questa pagina è possibile trovare un elenco di proprietà dell'immagine che è possibile generare , ma per la domanda qui sembra che tutto ciò di cui hai bisogno sia %we %hche fornisca rispettivamente la larghezza e l'altezza dell'immagine in pixel.

La flessibilità offerta da -formatme è stata utile per trovare le immagini più grandi in termini di pixel, producendo %[fx:w*h]un numero di immagini e ordinando l'output.

Potresti voler specificare l' -pingopzione se stai elaborando molte immagini, usando escape più complicati e vuoi assicurarti che il programma non perda tempo a caricare le immagini intere. Con semplici escape, -pingdovrebbe essere l'impostazione predefinita. Maggiori informazioni sulla scelta tra -pinge +pingpossono essere trovate qui .

puoi semplicemente usare il comando "file" per ottenere le informazioni di cui hai bisogno:

~# file cha_2.png 
cha_2.png: PNG image data, 656 x 464, 8-bit/color RGB, non-interlaced

Usa identifyper vedere le dimensioni:

$ identify color.jpg 
> color.jpg JPEG 1980x650 1980x650+0+0 8-bit DirectClass 231KB 0.000u 0:00.000

Estrai valore tramite cut | sed, dal campo 3:

identify ./color.jpg | cut -f 3 -d " " | sed s/x.*// #width
identify ./color.jpg | cut -f 3 -d " " | sed s/.*x// #height

Assegna a variabile:

W=`identify ./color.jpg | cut -f 3 -d " " | sed s/x.*//` #width
H=`identify ./color.jpg | cut -f 3 -d " " | sed s/.*x//` #height
echo $W
> 1980
echo $H
> 650

Entrambi displaye filesono piuttosto lenti e hanno il potenziale per mettere in ginocchio anche sistemi abbastanza capaci di gestire molti file multipli. Un piccolo test:

     $ du -h *.png --total | tail -n 1
     9.2M    total

     $ ls -l *.png | wc -l
     107

     $ /usr/bin/time file *.png
-->  0.37user 0.26system 0:06.93elapsed 9%CPU (0avgtext+0avgdata 37232maxresident)k
     22624inputs+0outputs (9major+2883minor)pagefaults 0swaps

     $ /usr/bin/time identify *.png
-->  0.56user 0.22system 0:06.77elapsed 11%CPU (0avgtext+0avgdata 25648maxresident)k
     34256inputs+0outputs (119major+2115minor)pagefaults 0swaps

Leggendo solo i byte necessari, questa operazione può essere velocizzata in modo significativo.

     $ /usr/bin/time ./pngsize *.png
-->  0.00user 0.00system 0:00.03elapsed 12%CPU (0avgtext+0avgdata 1904maxresident)k
     0inputs+0outputs (0major+160minor)pagefaults 0swaps

Ecco pngsize:

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <err.h>
#define oops(syscall) { printf("error processing %s: ", argv[i]); \
        fflush(0); perror(syscall"()"); continue; }
int main(int argc, char **argv) {
    int fd, i;
    uint32_t h, w;
    if (argc < 2) { printf("%s <pngfile> [pngfile ...]\n", argv[0]); exit(0); }
    for (i = 1; i < argc; i++) {
        if (argc > 2) printf("%s: ", argv[i]);
        if ((fd = open(argv[i], O_RDONLY)) == -1) oops("open");
        if (lseek(fd, 16, SEEK_SET) == -1) oops("lseek");
        if (read(fd, &w, 4) < 1) oops("read");
        if (read(fd, &h, 4) < 1) oops("read");
        printf("%dx%d\n", htonl(w), htonl(h));
        if (close(fd) == -1) oops("close");
    }
    return 0;
}

Questo metodo è molto più veloce dell'uso di una libreria che carica il PNG in avanti, indietro e lateralmente solo per ottenere la dimensione dell'immagine: P (Considera attentamente il codice prima di dargli una directory piena di PNG arbitrari, ovviamente.)

Il codice usa inet.h per htonl () per de- endian -ize l'ordinamento dei byte di intestazione.

Puoi anche provare GraphicsMagick , che è un fork ben mantenuto di ImageMagick usato ad es. Flickr ed Etsy:

$ gm identify a.jpg
a.jpg JPEG 480x309+0+0 DirectClass 8-bit 25.2K 0.000u 0:01

È più veloce dell'identificazione di ImageMagick (nei miei test circa due volte).

Questo è stato un utile frammento (non ho scritto) che restituisce dimensioni per ogni png e jpg nella cartella:

file ./* | perl -ne '@m = /^.*.jpg|^.*.png|[0-9][0-9]*[ ]?x[ ]?[0-9][0-9]*/g; print "@m\n"'

Per quelli come me che vogliono le dimensioni in megapixel:

perl -le "printf \"=> fileName = %s size = %.2f Mpix\n\", \"$fileName\", $(identify -format '%w*%h/10**6' $fileName)"