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 lorsque cela est nécessaire. Par exemple, le curseur d'accueil n'utilisera que 10 images; je ne veux pas que les 1 000 autres images aient cette vignette générée, ce qui est une perte de temps et d'espace.
Il existe un moyen de renvoyer add_image_size uniquement lorsque cela est nécessaire?
Merci
UPDATEComme vous le mentionnez, ce n'est pas vraiment add_image_size qui doit être déclenché. Ce qui serait génial 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, miniatures de portefeuille, etc., j'ai 1000 images et je veux seulement redimensionner 10 images pour le curseur.
J'espère que c'est clair maintenant, désolé pour mon anglais
Jetez un coup d'oeil à Otto's plug-in Dynamic Image Resizer
Ce plugin modifie la façon dont WordPress crée des images pour lui permettre de générer les images uniquement 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 un envoi rapide ultérieur par le serveur Web. Le résultat est que l'espace est économisé (puisque les images ne sont créées que lorsque cela est nécessaire) et que le téléchargement des images est beaucoup plus rapide (puisqu'il ne génère plus d'images à télécharger).
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 ensuite demandée dans une taille particulière, qui n'est pas encore générée, elle ne sera créée qu'une 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 rompt 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 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);
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 encore 1 à 2 par image pour voir 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 absolument traiter les vignettes à un moment différent, jetez un coup d'œil à Viper's Regenerate Thumbnails plugin. Il utilise une action à la demande pour régénérer all de vos vignettes d'image ... mais vous pouvez utiliser un code similaire pour générer des vignettes uniquement lorsque cela est nécessaire.
Il existe 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 la supprimer immédiatement après.
J'imagine que votre plus gros défi serait de trouver comment différencier les images nécessitant des tailles supplémentaires de celles qui ne le sont pas.
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 lorsque cela est nécessaire. Vous pouvez également nettoyer les tailles d’image existantes afin qu’elles puissent se régénérer.
Vous pouvez utiliser my (not Ottos)"Redimensionnement d'image dynamique" 1) brancher.
“Dynamic Image Resize” est un plugin WordPress (MU-) offrant un shortcode et une balise de gabarit pour redimensionner les images “en vol” sans avoir besoin de TimThumb, mais avec les fonctions principales WP.
Le plugin est livré avec une balise de template et un shortcode .
1) Je viens de découvrir le plugin Ottos. Nommer collision n'était pas prévu.
WP Performance Pack le plugin offre une "gestion améliorée des images", basée sur Ottos Dynamic Image Resizer, mais comprenant 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 vignettes peut être désactivée (mais elles peuvent être mises en cache et le support CDN est activé), l’intégration Regenerate Thumbails (pour supprimer les vignettes existantes) et quelques autres.