Comment générer des vignettes en cas de besoin uniquement?

J'ai 1000 images. Comment puis-je faire wordpress pour générer le pouce uniquement en cas de besoin. Par exemple, le curseur d'accueil n'utilisera que 10 images, je ne veux pas que les 1000 autres images aient cette miniature générée comme une perte d'espace et de ressources.

Il existe un moyen de déclencher add_image_size uniquement en cas de besoin?

Merci

MISE À JOUR Comme vous le mentionnez, ce n'est pas vraiment add_image_size ce dont il a besoin pour être tiré. Ce serait génial de déclencher le redimensionnement de l'image lorsque j'utilise the_post_thumbnail ('slider-thumb'); Peut-être que ce ralentissement est la première vue de l'image, mais cette vue est généralement générée par moi lorsque je passe en revue le message, donc je m'en fiche.

Donc, entre mes messages, curseur, vignettes de blog, vignettes de portefeuille, etc., j'ai 1000 images et je veux que 10 images soient redimensionnées pour le curseur.Je vois beaucoup de ressources gaspillées pour générer la taille de vignette pour les 990 autres images.

J'espère que c'est clair maintenant, désolé pour mon anglais

Jetez un œil au plugin Dynamic Image Resizer d' Otto

Ce plugin change la façon dont WordPress crée des images pour qu'il ne génère les images que lorsqu'elles sont réellement utilisées quelque part, à la volée. Les images ainsi créées seront enregistrées dans les répertoires de téléchargement normaux, pour être ensuite envoyées rapidement par le serveur Web. Le résultat est que l'espace est économisé (car les images ne sont créées que lorsque cela est nécessaire), et le téléchargement d'images est beaucoup plus rapide (car il ne génère plus les images lors du téléchargement).

Mettez ceci dans votre fichier de fonctions de thème. Cela empêchera Wordpress de créer autre chose que les 3 tailles par défaut lors du téléchargement.

Lorsqu'une image est alors demandée dans une taille particulière, qui n'est pas encore générée, elle ne sera créée qu'une seule fois.

        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']
            );
        }

Malheureusement, la réponse de @ Patrick casse les fonctions srcset introduites dans WP 4.4. Heureusement, nous avons juste besoin d'ajouter deux fonctions supplémentaires!

Tout d'abord, nous devons réintroduire temporairement toutes les tailles de vignettes enregistrées dans les métadonnées d'image afin qu'elles puissent être prises en compte:

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);

Ensuite, nous devons parcourir les correspondances et générer les miniatures manquantes:

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 fait, add_image_size()ne génère pas la miniature, il enregistre simplement une taille d'image disponible sur WordPress.

En règle générale, les vignettes sont générées lors du premier téléchargement de l'image. C'est un processus automatique, vous n'avez donc pas à vous soucier de les générer plus tard. Pensez-y de cette façon - si cela prend 1-2 secondes pour générer une vignette sur un serveur lent et que vous attendez jusqu'à ce qu'il soit demandé, vous forcez le demandeur à attendre 1-2 secondes supplémentaires par image pour voir le contenu. Il est beaucoup plus facile de le faire à l'avance, c'est-à-dire lorsque l'image est téléchargée.

En même temps, si vous devez absolument traiter les vignettes à un autre moment, vous voudrez peut-être jeter un œil au plugin Viper Regenerate Thumbnails . Il utilise une action à la demande pour régénérer toutes vos vignettes d'images ... mais vous pouvez utiliser un code similaire pour générer des vignettes uniquement en cas de besoin.

Il existe un moyen de déclencher add_image_size uniquement en cas de besoin?

Pas exactement. Mais vous pouvez filtrer la liste des tailles enregistrées juste avant la génération des miniatures. La fonction wp_generate_attachment_metadata () (qui appelle la fonction qui génère les miniatures) possède un filtre appelé "intermediaire_image_sizes_advanced", qui vous permet de manipuler le tableau de tailles juste avant la génération des fichiers. Vous pouvez utiliser ce filtre chaque fois que vous ajoutez une image d'un certain "type", puis la supprimer immédiatement après.

Je suppose que votre plus grand défi serait de comprendre comment faire la différence entre les images qui ont besoin de tailles supplémentaires et celles qui n'en ont pas besoin.

Vous pouvez utiliser mon (pas Ottos ⁾ plugin "Dynamic Image Resize" ¹⁾ .

«Dynamic Image Resize» est un plugin WordPress (MU-) qui offre un shortcode et une balise de modèle pour redimensionner les images «en vol» sans avoir besoin de TimThumb, mais avec les fonctions principales de WP.

Le plugin est également livré avec une balise de modèle et un shortcode .

^{1) Je viens de découvrir le plugin Ottos. La collision de noms n'était pas prévue.}

Vous pouvez essayer ce plugin: https://wordpress.org/plugins/optimize-images-resizing

Il redimensionne les images en fonction de la taille de votre image enregistrée, mais uniquement en cas de besoin. Peut également nettoyer les tailles d'image existantes afin qu'elles puissent se régénérer.

Le plugin WP Performance Pack offre une "gestion d'image améliorée", basée sur Ottos Dynamic Image Resizer, mais comprend de nombreuses améliorations, par exemple: tout d'abord, il est compatible avec la dernière version de WordPress (3.9.1), utilise WP_Image_Editor, la sauvegarde des miniatures peut être désactivé (mais ils peuvent être mis en cache et le support CDN est en cours), l'intégration de régénération des vignettes (pour supprimer les vignettes existantes) et bien plus encore.

Vous pouvez également essayer Aqua Resizer - https://github.com/syamilmj/Aqua-Resizer/

C'est juste un fichier.

Vous pouvez l'utiliser comme ceci:

$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

Voici encore une autre approche: son accroche dans la gestion des erreurs HTTP 404. Autrement dit, lorsque la vignette n'est pas disponible, recherchez l'image d'origine et créez la vignette. Notez que cela ne résout pas vraiment votre problème, car il n'empêche pas la génération de vignettes pendant le téléchargement.

Notez également que ce plugin peut être utilisé par des utilisateurs malveillants pour créer un nombre quelconque de miniatures et ainsi épuiser votre espace disque.

Remarque: ce plugin peut être facilement installé à l'aide de 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();
}