Come Ridimensionare Dinamicamente le Immagini WordPress Al Volo (campo personalizzato/opzione tema)

Ridimensiona le immagini di WordPress al volo utilizzando le funzioni integrate di WordPress.

Utilizza la funzione vt_resize per ridimensionare dinamicamente le immagini di WordPress situate in un campo personalizzato, nell'immagine in evidenza, nella directory degli upload, nel plugin NextGen Gallery per WordPress o anche in un link esterno a un'immagine fuori dal sito.

È molto semplice da usare, basta copiare/incollare il codice qui sotto nel file functions.php del tuo tema WordPress attualmente attivo.

Poi, ovunque tu abbia bisogno di ridimensionare un'immagine al volo, basta inserire una chiamata a quella funzione seguendo i parametri spiegati nei commenti della funzione.

Ecco un esempio di come ottenere automaticamente l'ID del Post, il Post stesso, i valori dei Campi Personalizzati del Post e ridimensionare dinamicamente l'immagine dal Campo Personalizzato che contiene l'immagine da ridimensionare dinamicamente al volo.

<?php

# Inserisci questo nel tuo functions.php
function get_postID() {

    global $wp_query;

    return $wp_query->post->ID;

}

?>

<?php

# Inserisci le seguenti righe dove vuoi eseguire questa azione.
$postID = get_postID(); // Ottieni l'ID del Post corrente.
$post   = get_post( $postID ); // Prende l'ID del Post corrente e restituisce il record del database. (alternativamente, `global $post`)
$custom = get_post_custom( $post->ID ); // Restituisce un array multidimensionale con tutti i campi personalizzati del Post.
$image  = $custom['field-slug'][0]; // Specifica la chiave dell'array del Campo Personalizzato che contiene l'immagine.

# Il primo parametro è 0. Significa che non verrà utilizzato un Allegato del Post.
# Il secondo parametro è l'URL dell'immagine dal valore del Campo Personalizzato del Post.
# Il terzo e il quarto parametro sono la larghezza e l'altezza dell'immagine dopo il ridimensionamento.
# Il quinto parametro significa ritagliare questa immagine.

$resizedImage = vt_resize( 0, $image, 190, 338, true ); // Ridimensiona dinamicamente l'immagine al volo.

echo '<img src="' . $resizedImage[ 'url' ] . '" width="' . $resizedImage[ 'width' ] . '" height="' . $resizedImage[ 'height' ] . '" title="' . $post->post_title . '" alt="' . $post->post_title . '" />'; // Le proprietà dell'immagine sono contenute in un array. (Usa print_r($resizedImage) per le proprietà dell'array.)

?>

Ridimensiona le immagini di WordPress al volo con vt_resize con supporto multi-sito

• Descrizione: Ridimensiona le immagini dinamicamente utilizzando le funzioni integrate di WordPress.
• Autore: Victor Teixeira
• Requisiti: PHP 5.2+, WordPress 3.2+

Ho riformattato il codice sorgente in modo che sia più leggibile per i miei occhi. Se vuoi il codice sorgente originale formattato, visita il link sopra.

<?php

if ( ! function_exists( 'vt_resize' ) ) {

    /**
     * Ridimensiona le immagini dinamicamente utilizzando le funzioni integrate di wp
     * Victor Teixeira
     *
     * php 5.2+
     *
     * Esempio di utilizzo:
     *
     * <?php
     * $thumb = get_post_thumbnail_id();
     * $image = vt_resize($thumb, '', 140, 110, true);
     * ?>
     * <img src="<?php echo $image[url]; ?>" width="<?php echo $image[width]; ?>" height="<?php echo $image[height]; ?>" />
     *
     * @param int    $attach_id
     * @param string $img_url
     * @param int    $width
     * @param int    $height
     * @param bool   $crop
     *
     * @return array|void
     */
    function vt_resize( int $attach_id = 0, string $img_url = '', int $width = 0, int $height = 0, bool $crop = false ) {

        if ( $attach_id ) {

            #  questo è un allegato, quindi abbiamo l'ID
            $image_src = wp_get_attachment_image_src( $attach_id, 'full' );
            $file_path = get_attached_file( $attach_id );

        } elseif ( $img_url ) {

            #  questo non è un allegato, usiamo l'URL dell'immagine
            $file_path = parse_url( $img_url );
            $file_path = $_SERVER['DOCUMENT_ROOT'] . $file_path['path'];

            #  Cerca il percorso Multisito
            if ( file_exists( $file_path ) === false ) {

                global $blog_id;

                $file_path = parse_url( $img_url );

                if ( preg_match( '/files/', $file_path['path'] ) ) {

                    $path = explode( '/', $file_path['path'] );

                    foreach ( $path as $k => $v ) {

                        if ( $v == 'files' ) {
                            $path[ $k - 1 ] = 'wp-content/blogs.dir/' . $blog_id;
                        }

                    }

                    $path = implode( '/', $path );
                }

                $file_path = $_SERVER['DOCUMENT_ROOT'] . $path;

            }

            // $file_path = ltrim( $file_path['path'], '/' );
            // $file_path = rtrim( ABSPATH, '/' ).$file_path['path'];
            $orig_size    = getimagesize( $file_path );
            $image_src[0] = $img_url;
            $image_src[1] = $orig_size[0];
            $image_src[2] = $orig_size[1];

        }

        $file_info = pathinfo( $file_path );

        #  controlla se il file esiste
        $base_file = $file_info['dirname'] . '/' . $file_info['filename'] . '.' . $file_info['extension'];

        if ( ! file_exists( $base_file ) ) {
            return;
        }

        $extension = '.' . $file_info['extension'];

        #  il percorso dell'immagine senza l'estensione
        $no_ext_path      = $file_info['dirname'] . '/' . $file_info['filename'];
        $cropped_img_path = $no_ext_path . '-' . $width . 'x' . $height . $extension;

        #  controlla se la dimensione del file è maggiore della dimensione target
        #  se è più piccola o della stessa dimensione, fermati qui e restituisci
        if ( $image_src[1] > $width ) {

            #  il file è più grande, controlla se esiste già la versione ridimensionata (per $crop = true ma funzionerà anche per $crop = false se le dimensioni corrispondono)
            if ( file_exists( $cropped_img_path ) ) {

                $cropped_img_url = str_replace( basename( $image_src[0] ), basename( $cropped_img_path ), $image_src[0] );

                $vt_image = array(
                    'url'    => $cropped_img_url,
                    'width'  => $width,
                    'height' => $height
                );

                return $vt_image;

            }

            #  $crop = false o altezza non impostata
            if ( $crop == false OR ! $height ) {

                #  calcola la dimensione proporzionalmente
                $proportional_size = wp_constrain_dimensions( $image_src[1], $image_src[2], $width, $height );
                $resized_img_path  = $no_ext_path . '-' . $proportional_size[0] . 'x' . $proportional_size[1] . $extension;

                #  controlla se il file esiste già
                if ( file_exists( $resized_img_path ) ) {

                    $resized_img_url = str_replace( basename( $image_src[0] ), basename( $resized_img_path ), $image_src[0] );

                    $vt_image = array(
                        'url'    => $resized_img_url,
                        'width'  => $proportional_size[0],
                        'height' => $proportional_size[1]
                    );

                    return $vt_image;

                }

            }

            #  controlla se la larghezza dell'immagine è minore della larghezza impostata
            $img_size = getimagesize( $file_path );

            if ( $img_size[0] <= $width ) {
                $width = $img_size[0];
            }

            #  Controlla se la libreria GD è installata
            if ( ! function_exists( 'imagecreatetruecolor' ) ) {

                echo 'Errore libreria GD: imagecreatetruecolor non esiste - contatta il tuo webhost e chiedi di installare la libreria GD';

                return;
            }

            #  nessun file di cache - finalmente ridimensioniamo
            $new_img_path = image_resize( $file_path, $width, $height, $crop );
            $new_img_size = getimagesize( $new_img_path );
            $new_img      = str_replace( basename( $image_src[0] ), basename( $new_img_path ), $image_src[0] );

            #  output ridimensionato
            $vt_image = array(
                'url'    => $new_img,
                'width'  => $new_img_size[0],
                'height' => $new_img_size[1]
            );

            return $vt_image;

        }

        #  output predefinito - senza ridimensionamento
        $vt_image = array(
            'url'    => $image_src[0],
            'width'  => $width,
            'height' => $height
        );

        return $vt_image;
    }

}

?>