Come generare miniature solo quando necessario?

Inserisci questo nel file functions.php del tuo tema. Impedirà a WordPress di creare qualsiasi dimensione diversa dalle 3 dimensioni predefinite durante il caricamento.

Quando un'immagine viene poi richiesta in una dimensione specifica, che non è ancora stata generata, verrà creata solo quella volta.

        add_filter('image_downsize', 'ml_media_downsize', 10, 3);
        function ml_media_downsize($out, $id, $size) {
            // Se la dimensione dell'immagine esiste, lascia che WordPress la serva normalmente
            $imagedata = wp_get_attachment_metadata($id);
            if (is_array($imagedata) && isset($imagedata['sizes'][$size]))
                return false;

            // Verifica che la dimensione richiesta esista, altrimenti interrompi
            global $_wp_additional_image_sizes;
            if (!isset($_wp_additional_image_sizes[$size]))
                return false;

            // Crea la nuova miniatura
            if (!$resized = image_make_intermediate_size(
                get_attached_file($id),
                $_wp_additional_image_sizes[$size]['width'],
                $_wp_additional_image_sizes[$size]['height'],
                $_wp_additional_image_sizes[$size]['crop']
            ))
                return false;

            // Salva i metadati dell'immagine, altrimenti WordPress non potrà vedere che la miniatura esiste ora
            $imagedata['sizes'][$size] = $resized;
            wp_update_attachment_metadata($id, $imagedata);

            // Restituisce l'array per visualizzare l'immagine ridimensionata
            $att_url = wp_get_attachment_url($id);
            return array(dirname($att_url) . '/' . $resized['file'], $resized['width'], $resized['height'], true);
        }


        add_filter('intermediate_image_sizes_advanced', 'ml_media_prevent_resize_on_upload');
        function ml_media_prevent_resize_on_upload($sizes) {
            // Rimuovere queste impostazioni predefinite potrebbe causare problemi, quindi non lo facciamo
            return array(
                'thumbnail' => $sizes['thumbnail'],
                'medium' => $sizes['medium'],
                'large' => $sizes['large']
            );
        }

Sfortunatamente la risposta di @Patrick interrompe le funzioni srcset introdotte in WP 4.4. Fortunatamente, dobbiamo solo aggiungere due funzioni aggiuntive!

Innanzitutto, dobbiamo temporaneamente reintrodurre tutte le dimensioni delle miniature registrate nei metadati dell'immagine in modo che possano essere considerate:

function bi_wp_calculate_image_srcset_meta($image_meta, $size_array, $image_src, $attachment_id){
    //tutte le dimensioni registrate
    global $_wp_additional_image_sizes;

    //alcune specifiche del file sorgente che useremo spesso
    $src_path = get_attached_file($attachment_id);
    $src_info = pathinfo($src_path);
    $src_root = trailingslashit($src_info['dirname']);
    $src_ext = $src_info['extension'];
    $src_mime = wp_check_filetype($src_path);
    $src_mime = $src_mime['type'];
    $src_base = wp_basename($src_path, ".$src_ext");

    //trova cosa manca
    foreach($_wp_additional_image_sizes AS $k=>$v)
    {
        if(!isset($image_meta['sizes'][$k]))
        {
            //prima, scopriamo come si comporterebbe dimensionalmente
            $new_size = image_resize_dimensions($image_meta['width'], $image_meta['height'], $v['width'], $v['height'], $v['crop']);
            if(!$new_size)
                continue;
            $new_w = (int) $new_size[4];
            $new_h = (int) $new_size[5];

            //valori non validi
            if(!$new_h || !$new_w)
                continue;

            //genera un nome file come farebbe WP_Image_Editor
            $new_f = wp_basename("{$src_root}{$src_base}-{$new_w}x{$new_h}." . strtolower($src_ext));

            //finalmente, aggiungilo!
            $image_meta['sizes'][$k] = array(
                'file'      => $new_f,
                'width'     => $new_w,
                'height'    => $new_h,
                'mime-type' => $src_mime
            );
        }
    }

    return $image_meta;
}
add_filter('wp_calculate_image_srcset_meta', 'bi_wp_calculate_image_srcset_meta', 10, 4);

Poi dobbiamo scorrere le corrispondenze e generare eventuali miniature mancanti:

function bi_wp_calculate_image_srcset($sources, $size_array, $image_src, $image_meta, $attachment_id){

    //ottieni alcune informazioni sul sorgente
    $src_path = get_attached_file($attachment_id);
    $src_root = trailingslashit(pathinfo($src_path, PATHINFO_DIRNAME));

    //i metadati effettivi dell'immagine (che potrebbero essere modificati qui)
    $src_meta = wp_get_attachment_metadata($attachment_id);

    //un array di dimensioni possibili da cercare
    $sizes = $image_meta['sizes'];
    unset($sizes['thumbnail']);
    unset($sizes['medium']);
    unset($sizes['large']);

    $new = false;

    //scorri le sorgenti
    foreach($sources AS $k=>$v)
    {
        $name = wp_basename($v['url']);
        if(!file_exists("{$src_root}{$name}"))
        {
            //trova la dimensione corrispondente
            foreach($sizes AS $k2=>$v2)
            {
                //abbiamo una corrispondenza!
                if($v2['file'] === $name)
                {
                    //creala
                    if(!$resized = image_make_intermediate_size(
                        $src_path,
                        $v2['width'],
                        $v2['height'],
                        $v2['crop']
                    )){
                        //rimuovi dalle sorgenti in caso di fallimento
                        unset($sources[$k]);
                    }
                    else
                    {
                        //aggiungi la nuova miniatura ai metadati veri
                        $new = true;
                        $src_meta['sizes'][$k2] = $resized;
                    }

                    //rimuovi dall'array delle dimensioni così abbiamo
                    //meno da cercare la prossima volta
                    unset($sizes[$k2]);
                    break;
                }//corrispondenza
            }//ogni dimensione
        }//ogni 404
    }//ogni sorgente

    //se abbiamo generato qualcosa, aggiorna i metadati dell'allegato
    if($new)
        wp_update_attachment_metadata($attachment_id, $src_meta);

    return $sources;
}
add_filter('wp_calculate_image_srcset', 'bi_wp_calculate_image_srcset', 10, 5);

In realtà, la funzione add_image_size() non genera il thumbnail, si limita a registrare una dimensione di immagine come disponibile in WordPress.

Normalmente, i thumbnail vengono generati quando l'immagine viene caricata per la prima volta. È un processo automatico, quindi non devi preoccuparti di generarli successivamente. Pensa in questo modo - se su un server lento ci vogliono 1-2 secondi per generare un thumbnail e aspetti che venga richiesto, costringi l'utente ad aspettare 1-2 secondi aggiuntivi per ogni immagine per vedere il contenuto. È molto più efficiente farlo in anticipo - cioè quando l'immagine viene caricata.

Allo stesso tempo, se devi assolutamente processare i thumbnail in un momento diverso, potresti dare un'occhiata al plugin Viper's Regenerate Thumbnails. Utilizza un'azione on-demand per rigenerare tutti i thumbnail delle immagini... ma potresti usare un codice simile per generare i thumbnail solo quando necessario.

Esiste un modo per attivare add_image_size solo quando necessario?

Non esattamente. Ma puoi filtrare la lista delle dimensioni registrate appena prima che le miniature vengano generate. La funzione wp_generate_attachment_metadata() (che chiama la funzione che genera le miniature) ha un filtro chiamato "intermediate_image_sizes_advanced", che ti permette di manipolare l'array delle dimensioni proprio prima che i file vengano generati. Potresti usare questo filtro ogni volta che stai aggiungendo un'immagine di un certo "tipo", e poi rimuoverlo immediatamente dopo.

Immagino che la tua sfida più grande sarebbe capire come differenziare tra le immagini che necessitano delle dimensioni extra e quelle che non ne hanno bisogno.

Puoi utilizzare il mio plugin (non quello di Ottos) "Dynamic Image Resize" ¹⁾.

"Dynamic Image Resize" è un plugin (MU) per WordPress che offre uno shortcode e un template tag per ridimensionare le immagini "al volo" senza bisogno di TimThumb, ma utilizzando le funzioni core di WordPress.

Il plugin include sia un template tag che uno shortcode.

^{1) Ho scoperto solo ora il plugin di Otto. La collisione di nomi non era intenzionale.}

Puoi provare questo plugin: https://wordpress.org/plugins/optimize-images-resizing

Ridimensiona le immagini in base alle dimensioni registrate, ma solo quando necessario. Inoltre può ripulire le dimensioni esistenti delle immagini in modo che possano essere rigenerate.

Il plugin WP Performance Pack offre una "gestione avanzata delle immagini", basata su Ottos Dynamic Image Resizer, ma include numerosi miglioramenti, ad esempio: Innanzitutto è compatibile con l'ultima versione di WordPress (3.9.1), utilizza WP_Image_Editor, è possibile disattivare il salvataggio delle miniature (ma possono essere memorizzate nella cache e il supporto per CDN è in arrivo), integrazione con Regenerate Thumbnails (per eliminare le miniature esistenti) e molto altro ancora.

Ecco un altro approccio: si aggancia alla gestione degli errori HTTP 404. Cioè, quando una miniatura non è disponibile, trova l'immagine originale e crea la miniatura. Nota che questo non risolve realmente il tuo problema, poiché non impedisce la generazione delle miniature durante il caricamento.

Nota anche che questo plugin potrebbe essere utilizzato da utenti malintenzionati per creare un numero qualsiasi di miniature e quindi esaurire lo spazio sul disco.

Nota: Questo plugin può essere facilmente installato utilizzando Pluginception.

<?php
/*
Plugin Name: Crea miniature su richiesta
Plugin URI: 
Description: Crea miniature invece di mostrare errori 404. Utilizza in combinazione con "Broken Link Checker" per creare tutte le miniature mancanti.
Version: 0.1
Author: Jack Miller
Author URI: 
License: 
License URI: 
*/
add_filter('status_header', 'createThumbIf404');
function createThumbIf404($httpCodeString) //es. HTTP/1.1 200 OK 
{
    global $wp_query;
    error_reporting(E_ALL);
    ini_set('display_errors', 1);

    $httpCode = explode(" ", $httpCodeString);
    $httpCode = $httpCode[1];
    if ($httpCode == "404") {
        $requestUri = $_SERVER["REQUEST_URI"];
        $regex = '/^\/(wp-content\/uploads\/(?:[a-zA-Z0-9]*\/){2})(.*)-(.*)x(.*)\.jpg$/';
        preg_match($regex, $requestUri, $groups);
        if (sizeof($groups) === 5) {
            $baseDir  = $groups[1];
            $baseName = $groups[2];
            $sizeX    = $groups[3];
            $sizeY    = $groups[4];

            $oriImg = ctod_checkFile($baseDir, $baseName);
            if ($oriImg != null) {

                $image = wp_get_image_editor($baseDir . $oriImg);
                if (!is_wp_error($image)) {
                    $image->resize($sizeX, $sizeY, true);
                    $thumb = $baseDir . $baseName . '-' . $sizeX . 'x' . $sizeY . '.jpg';
                    $image->save($thumb);
                    ctod_sendImageAndExit($thumb);
                }
            }
        }
    }
}
//Trova l'immagine originale all'interno di $baseDir con $baseName.
//Restituisce il nome del file, inclusa l'estensione dell'immagine originale o null.
function ctod_checkFile($baseDir, $baseName)
{
    $arr = array(
        ".jpg",
        ".JPG",
        ".jpeg",
        ".JPEG"
    );
    foreach ($arr as &$ext) {
        if (file_exists($baseDir . $baseName . $ext)) {
            return $baseName . $ext;
        }
    }
    return null;
}
//Legge il file in $path dal disco e lo restituisce come richiesta HTTP di immagine JPG.
function ctod_sendImageAndExit($path)
{
    $fp = fopen($path, 'rb');
    header("Content-Type: image/jpeg");
    header("Content-Length: " . filesize($path));
    fpassthru($fp);
    exit();
}

In altri luoghi tutte le dimensioni create funzioneranno, ma solo nel caricamento dei media, se vuoi caricare una dimensione specifica, di seguito è riportato il codice per farlo. Ecco il link per maggiori dettagli - https://developer.wordpress.org/reference/hooks/wp_handle_upload_prefilter/

add_filter('wp_handle_upload_prefilter', 'custom_upload_filter' );
 
function custom_upload_filter( $file ) {
   foreach ( get_intermediate_image_sizes() as $size ) {
        if ( !in_array( $size, array( 'thumbnail', 'medium', 'medium_large', 'large' ) ) ) {
            remove_image_size( $size );
        }
    }
    return $file;
}

Puoi provare anche Aqua Resizer - https://github.com/syamilmj/Aqua-Resizer/

È composto da un solo file.

Puoi usarlo in questo modo:

$img_src = aq_resize( $img_src, $width = null, $height = null, $crop = null, $single = true, $upscale = false );

$img_src = aq_resize( $img_src, 150, 150); // ridimensionato
$img_src = aq_resize( $img_src, 150, 150, true); // ritagliato
$img_src = aq_resize( $img_src, 150, 150, null, null, true); // un'immagine di 120x120 per esempio verrà scalata fino a 150x150