¿Cómo generar miniaturas cuando es necesario solo?

Eche un vistazo al complemento de Dynamic Image Resizer de Otto

  

Este complemento cambia la forma en que WordPress crea imágenes para hacerlo   generar las imágenes solo cuando realmente se utilizan en algún lugar, en el   volar. Las imágenes creadas de este modo se guardarán en la carga normal.   Directorios, para su posterior envío rápido por parte del servidor web. El resultado es   ese espacio se guarda (ya que las imágenes solo se crean cuando es necesario), y   subir imágenes es mucho más rápido (ya que no genera las imágenes   en subir ya).

Ponga esto en su archivo de funciones de tema. Evitará que Wordpress cree nada excepto los 3 tamaños predeterminados al cargar.

Cuando luego se solicita una imagen en un tamaño particular, que aún no se ha generado, se creará solo esa vez.

        add_filter('image_downsize', 'ml_media_downsize', 10, 3);
        function ml_media_downsize($out, $id, $size) {
            // If image size exists let WP serve it like normally
            $imagedata = wp_get_attachment_metadata($id);
            if (is_array($imagedata) && isset($imagedata['sizes'][$size]))
                return false;

            // Check that the requested size exists, or abort
            global $_wp_additional_image_sizes;
            if (!isset($_wp_additional_image_sizes[$size]))
                return false;

            // Make the new thumb
            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;

            // Save image meta, or WP can't see that the thumb exists now
            $imagedata['sizes'][$size] = $resized;
            wp_update_attachment_metadata($id, $imagedata);

            // Return the array for displaying the resized image
            $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) {
            // Removing these defaults might cause problems, so we don't
            return array(
                'thumbnail' => $sizes['thumbnail'],
                'medium' => $sizes['medium'],
                'large' => $sizes['large']
            );
        }

Desafortunadamente, la respuesta de @ Patrick rompe las funciones srcset introducidas en WP 4.4. Afortunadamente, solo necesitamos agregar dos funciones adicionales.

Primero, debemos volver a introducir temporalmente todos los tamaños de miniaturas registrados en los metadatos de la imagen para que puedan ser considerados:

function bi_wp_calculate_image_srcset_meta($image_meta, $size_array, $image_src, $attachment_id){
    //all registered sizes
    global $_wp_additional_image_sizes;

    //some source file specs we'll use a lot
    $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");

    //find what's missing
    foreach($_wp_additional_image_sizes AS $k=>$v)
    {
        if(!isset($image_meta['sizes'][$k]))
        {
            //first, let's find out how things would play out dimensionally
            $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];

            //bad values
            if(!$new_h || !$new_w)
                continue;

            //generate a filename the same way WP_Image_Editor would
            $new_f = wp_basename("{$src_root}{$src_base}-{$new_w}x{$new_h}." . strtolower($src_ext));

            //finally, add it!
            $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);

Luego debemos ejecutar las coincidencias y generar las miniaturas faltantes:

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

    //get some source info
    $src_path = get_attached_file($attachment_id);
    $src_root = trailingslashit(pathinfo($src_path, PATHINFO_DIRNAME));

    //the actual image metadata (which might be altered here)
    $src_meta = wp_get_attachment_metadata($attachment_id);

    //an array of possible sizes to search through
    $sizes = $image_meta['sizes'];
    unset($sizes['thumbnail']);
    unset($sizes['medium']);
    unset($sizes['large']);

    $new = false;

    //loop through sources
    foreach($sources AS $k=>$v)
    {
        $name = wp_basename($v['url']);
        if(!file_exists("{$src_root}{$name}"))
        {
            //find the corresponding size
            foreach($sizes AS $k2=>$v2)
            {
                //we have a match!
                if($v2['file'] === $name)
                {
                    //make it
                    if(!$resized = image_make_intermediate_size(
                        $src_path,
                        $v2['width'],
                        $v2['height'],
                        $v2['crop']
                    )){
                        //remove from sources on failure
                        unset($sources[$k]);
                    }
                    else
                    {
                        //add the new thumb to the true meta
                        $new = true;
                        $src_meta['sizes'][$k2] = $resized;
                    }

                    //remove from the sizes array so we have
                    //less to search next time
                    unset($sizes[$k2]);
                    break;
                }//match
            }//each size
        }//each 404
    }//each source

    //if we generated something, update the attachment meta
    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);

En realidad, add_image_size() no genera la miniatura, solo registra un tamaño de imagen disponible para WordPress.

Normalmente, las miniaturas se generan cuando la imagen se carga por primera vez. Es un proceso automático para que no tenga que preocuparse por generarlos más tarde. Piénselo de esta manera: si tarda 1-2s en generar una miniatura en un servidor lento y espera hasta que se solicite, obliga a la persona que solicita a que espere uno o dos por imagen para ver el contenido. Es mucho más fácil hacerlo antes de tiempo, es decir, cuando se carga la imagen.

Al mismo tiempo, si es absolutamente necesario procesar las miniaturas en un momento diferente, es posible que desee echar un vistazo a Viper's Regenerate Thumbnails plugin. Utiliza una acción bajo demanda para regenerar todas de sus miniaturas de imágenes ... pero puede usar un código similar para generar miniaturas solo cuando sea necesario.

  

¿Hay una forma de activar add_image_size solo cuando sea necesario?

No exactamente. Pero puede filtrar la lista de tamaños registrados justo antes de que se generen las miniaturas. La función wp_generate_attachment_metadata () (que llama a la función que genera las miniaturas) tiene un filtro llamado "middle_image_sizes_advanced", que le permite manipular la matriz de tamaños justo antes de que se generen los archivos. Puede usar este filtro cada vez que agregue una imagen de cierto "tipo" y luego elimínela inmediatamente.

Supongo que tu mayor desafío sería descubrir cómo diferenciar las imágenes que necesitan tamaños adicionales y las que no.

Puede usar mi (no Ottos) "Redimensionar imagen dinámica" ¹⁾ plugin.

  

"Dynamic Image Resize" es un complemento de WordPress (MU-) que ofrece un código corto y una etiqueta de plantilla para cambiar el tamaño de las imágenes "en el vuelo" sin la necesidad de TimThumb, pero con funciones básicas de WP.

El complemento viene con una etiqueta de plantilla y un código corto también.

^{1) Acabo de descubrir el complemento Ottos. La colisión de nombres no estaba destinada.}

Puedes probar este plugin: enlace

Cambia el tamaño de las imágenes según el tamaño de la imagen registrada, pero solo cuando es necesario. También puede limpiar los tamaños de imagen existentes para que puedan regenerarse.

El complemento WP Performance Pack ofrece un "manejo mejorado de la imagen", que se basa en Ottos Dynamic Image Resizer, pero incluye muchas mejoras, por ejemplo: en primer lugar, es compatible con la última versión de WordPress (3.9.1), usa WP_Image_Editor, se puede desactivar el almacenamiento de miniaturas (pero se pueden almacenar en caché y el soporte de CDN está en camino), regenerar miniaturas integración (para eliminar las miniaturas existentes) y algunas más.

También puede probar Aqua Resizer - enlace

Es solo un archivo.

Puedes usarlo así:

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

$img_src = aq_resize( $img_src, 150, 150); // resized
$img_src = aq_resize( $img_src, 150, 150, true); // cropped
$img_src = aq_resize( $img_src, 150, 150, null, null, true); // image with 120x120 for example will be upscaled up to 150x150

Aquí hay otro enfoque: se enlaza con el manejo de errores HTTP 404. Es decir, cuando la imagen en miniatura no está disponible, busque la imagen original y cree la imagen en miniatura. Tenga en cuenta que esto no resuelve realmente su problema, ya que no evita la generación de miniaturas durante la carga.

Tenga en cuenta también que este complemento puede ser utilizado por usuarios malintencionados para crear cualquier cantidad de miniaturas y, por lo tanto, para agotar el espacio en el disco.

Nota: este complemento se puede instalar fácilmente usando Pluginception .

<?php
/*
Plugin Name: Create thumbnails on demand
Plugin URI: 
Description: Create thumbnails instead of showing 404. Use in combination with "Broken Link Checker" to create all missing thumbnails.
Version: 0.1
Author: Jack Miller
Author URI: 
License: 
License URI: 
*/
add_filter('status_header', 'createThumbIf404');
function createThumbIf404($httpCodeString) //e.g. 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);
                }
            }
        }
    }
}
//finds original image within $baseDir with $baseName.
//Returns file name including extension of original image or 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;
}
//Read file at $path from disk and return it as HTTP JPG image request.
function ctod_sendImageAndExit($path)
{
    $fp = fopen($path, 'rb');
    header("Content-Type: image/jpeg");
    header("Content-Length: " . filesize($path));
    fpassthru($fp);
    exit();
}