Comment générer des vignettes uniquement lorsque cela est nécessaire?

15

J'ai 1000 images. Comment puis-je faire wordpress pour générer le pouce uniquement lorsque cela est nécessaire. Par exemple, le curseur d'accueil n'utilisera que 10 images. Je ne souhaite pas que la vignette générée sur les 1000 autres images soit générée, ce qui représente un gaspillage d'espace et de ressources.

Y a-t-il un moyen de renvoyer add_image_size uniquement lorsque cela est nécessaire?

Merci

UPDATE Comme vous le dites, add_image_size n'est pas vraiment ce qui doit être déclenché. Ce qui serait génial, c’est de déclencher le redimensionnement de l’image lorsque j’utilise the_post_thumbnail ('slider-thumb'); Peut-être que cela ralentit la première vue de l'image, mais cette vue est généralement générée par moi-même lorsque je vérifie réellement le message, donc je m'en fiche.

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

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

    
posée chifliiiii 25.05.2012 - 23:52

10 réponses

11

Consultez le plug-in Dynamic Image Resizer d'Otto .

  

Ce plugin change la façon dont WordPress crée des images pour le rendre   générer les images uniquement lorsqu'elles sont effectivement utilisées quelque part,   voler. Les images ainsi créées seront sauvegardées lors du téléchargement normal.   répertoires, pour un envoi rapide ultérieur par le serveur Web. Le résultat est   cet espace est enregistré (car les images ne sont créées qu'en cas de besoin), et   le téléchargement des images est beaucoup plus rapide (puisqu'il ne génère pas les images)   plus sur le téléchargement).

    
réponse donnée Chris_O 26.05.2012 - 01:42
5

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.

Quand une image est ensuite 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']
            );
        }
    
réponse donnée Patrick 28.11.2013 - 16:40
2

Malheureusement, la réponse de @ Patrick rompt les fonctions de jeu 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 de l'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 toutes les vignettes 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);
    
réponse donnée Josh 16.04.2016 - 07:08
1

En fait, add_image_size() ne génère pas la vignette, il enregistre simplement une taille d'image disponible pour 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 pour que vous n'ayez pas à vous soucier de les générer plus tard. Pensez-y de cette façon. S'il faut 1 à 2 secondes pour générer une vignette sur un serveur lent et que vous attendez jusqu'à ce que la requête soit demandée, vous forcez le demandeur à attendre 1 à 2 secondes supplémentaires par image . le contenu. C’est beaucoup plus facile de le faire à l’avance - c’est-à-dire lorsque l’image est téléchargée.

Dans le même temps, si vous devez impérativement traiter les vignettes à un moment différent, consultez Plug-in Régénérer de la Viper . Il utilise une action à la demande pour régénérer toutes toutes les vignettes de votre image ... mais vous pouvez utiliser un code similaire pour générer des vignettes uniquement lorsque cela est nécessaire.

    
réponse donnée EAMann 26.05.2012 - 00:07
1
  

Y a-t-il un moyen de renvoyer add_image_size uniquement lorsque cela est nécessaire?

Pas exactement. Mais vous pouvez filtrer la liste des tailles enregistrées juste avant que les vignettes ne soient générées. La fonction wp_generate_attachment_metadata () (qui appelle la fonction générant les vignettes) possède un filtre appelé "intermediate_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 supprimez-la immédiatement après.

Je suppose que votre plus grand défi serait de trouver un moyen de différencier les images nécessitant des tailles supplémentaires de celles qui ne le sont pas.

    
réponse donnée MathSmath 26.05.2012 - 00:27
1

Vous pouvez utiliser mon (pas Ottos) "redimensionnement d'image dynamique" 1) plugin.

  

"Dynamic Image Resize" est un plugin WordPress (MU) proposant un shortcode et une balise de gabarit pour redimensionner les images "en vol" sans recourir à TimThumb, mais avec les fonctions de base de WP.

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

1) Je viens de découvrir le plugin Ottos. La collision de nommage n’était pas prévue.

    
réponse donnée kaiser 29.06.2013 - 13:03
1

Vous pouvez essayer ce plugin: enlace

Il redimensionne les images en fonction de la taille de votre image enregistrée, mais uniquement lorsque cela est nécessaire. Vous pouvez également nettoyer les tailles d’image existantes afin qu’elles puissent se régénérer.

    
réponse donnée user2128576 30.07.2015 - 02:27
0
Le plugin

WP Performance Pack offre une "gestion améliorée des images" basée sur Ottos Dynamic Image Resizer, mais inclut de nombreuses améliorations, par exemple: tout d’abord compatible avec la dernière version de WordPress (3.9.1), utilise WP_Image_Editor, la sauvegarde des vignettes peut être désactivée (mais elles peuvent être mises en cache et la prise en charge de CDN est assurée), Régénérer les vignettes intégration (pour supprimer les vignettes existantes) et quelques autres.

    
réponse donnée Björn 14.05.2014 - 12:02
-1

Vous pouvez également essayer Aqua Resizer - enlace

Ce n'est qu'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
    
réponse donnée antongorodezkiy 17.03.2014 - 12:30
-1

Voici encore une autre approche: elle s’accroche à la gestion des erreurs HTTP 404. En d’autres termes, lorsque la vignette n’est pas disponible, recherchez l’image originale et créez-la. Notez que cela ne résout pas vraiment votre problème, car il ne prévient pas la génération de vignettes lors du téléchargement.

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

Remarque: ce plug-in peut facilement être 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();
}
    
réponse donnée Jack Miller 22.05.2016 - 07:16

Lire d'autres questions sur les étiquettes