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

18

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

chifliiiii
la source
2
Comment les miniatures sont-elles générées à partir des 990 images supplémentaires, plus un gaspillage d'espace et de ressources que 990 images inutilisées en premier lieu? Ne serait-il pas plus judicieux de télécharger uniquement les images que vous utilisez activement?
SickHippie
Même si des programmeurs plus qualifiés présentent des arguments valables contre votre idée, je la trouve intéressante. J'ai vu des plugins et des thèmes qui téléchargent des images sans générer de pouces (je ne sais pas lesquels pour le moment). Mais mon grand doute sur votre question est: quand allez-vous en avoir besoin? . Quel sera le filtre?
brasofilo
1
Tu m'as trompé. J'utilise les images 990 dans les messages, je n'utilise tout simplement pas le curseur de la maison. Certains d'entre eux ont besoin de pouces pour le portfolio, d'autres pour les pouces de blog, etc.
chifliiiii

Réponses:

12

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

Chris_O
la source
2
Notez que ce plugin a un problème avec l'ajout d'images à d'anciens messages. Patches bienvenus.
Otto
C'est exactement ce que je cherchais. Je vais essayer. Donc, cela ne fonctionne que sur les nouveaux messages?
chifliiiii
1
Pour ceux qui rencontrent cet article maintenant, voici un plugin similaire qui semble être activement développé: wordpress.org/plugins/fly-dynamic-image-resizer
Tim Malone
7

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']
            );
        }
Patrick
la source
Ce filer devrait être standard dans WordPress. Pourquoi générer chaque taille pour chaque image? J'ajoute ce code à mes thèmes personnalisés. Merci
Michaelkay
2
Bien mais maintenant, il générera toujours toutes les images si je n'ai besoin que d'une seule taille personnalisée ..
Gijs
Cela se produit lorsque j'utilise des objets image à partir de champs personnalisés avancés
Gijs
Ne fonctionne pas SI add_image_size a été précédemment défini avec les dimensions de l'image qui viennent d'être modifiées
Benjamin Intal
@Michaelkay il y a une pénalité de performance dans cette approche. Lorsque les images sont téléchargées puis générées pour toutes les tailles, cela signifie que le téléchargeur est celui qui a de la patience. Ce code oblige vos visiteurs à avoir plus de patience, et Google a prouvé que les sites qui prennent plus de 2 secondes à charger, font chuter 50% des gens. De plus, si votre site a des centaines de visites simultanées, cela entraînera l'arrêt de vos serveurs.
Tom Roggero
2

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);
Josh
la source
Juste un avertissement pour vous faire savoir que cela rompra les cultures difficiles! Il m'a fallu des heures pour découvrir que c'était le coupable. Je travaille sur une solution ...
Constantin Groß
1

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.

EAMann
la source
Je pense que vous n'avez pas compris le point. Il veut contrôler pour quelles images une vignette est nécessaire. Certaines images n'ont donc pas du tout besoin d'être redimensionnées.
Drunken Master
La plupart des gens testent les pages lors de l'insertion de photos (je me sens plutôt bien de tout dire) .Cela entraînera la génération des fichiers nécessaires une fois et votre fait. Dans mon cas, j'ai enregistré une taille d'image d'en-tête. Environ 1 image sur 20 que je télécharge est en fait pour l'en-tête. Donc 19 images sur 20 dans ma bibliothèque est une perte d'espace.
JpaytonWPD
1

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.

MathSmath
la source
je devrais ajouter une option ou une case à cocher lorsque je télécharge un média pour choisir les pouces que je veux générer par exemple. Ça sonne bien mais je ne sais pas comment faire ça
chifliiiii
1

Vous pouvez utiliser mon (pas Ottos ) plugin "Dynamic Image Resize" 1) .

«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.

kaiser
la source
1

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.

user2128576
la source
0

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.

Björn
la source
-1

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
antongorodezkiy
la source
-1

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();
}
Jack Miller
la source