Como gerar miniaturas quando necessário apenas?

Eu tenho 1000 imagens. Como posso fazer wordpress para gerar polegar apenas quando necessário. Por exemplo, o controle deslizante inicial usará apenas 10 imagens. Eu não quero que as outras 1000 imagens tenham essa miniatura gerada como um desperdício de espaço e recursos.

Existe uma maneira de disparar add_image_size somente quando necessário?

obrigado

ATUALIZAÇÃO Como você mencionou, não é realmente add_image_size o que ele precisa para ser demitido. O que seria ótimo é disparar o redimensionamento da imagem quando eu uso o_post_thumbnail ('slider-thumb'); Talvez essa desaceleração seja a primeira visualização da imagem, mas essa visualização geralmente é gerada por mim quando eu realmente reviso o post, então não me importo.

Então, entre minhas postagens, controle deslizante, miniaturas de blog, miniaturas de portfólio, etc., eu tenho 1000 imagens e quero que apenas 10 imagens sejam redimensionadas para o controle deslizante. Eu vejo muitos recursos desperdiçados para gerar o tamanho da miniatura para as outras 990 imagens.

Espero que esteja claro agora, desculpe pelo meu inglês

Dê uma olhada no plugin Dynamic Image Resizer da Otto

Este plug-in altera a maneira como o WordPress cria imagens para gerar as imagens somente quando elas são realmente usadas em algum lugar, em tempo real. As imagens criadas assim serão salvas nos diretórios normais de upload, para posterior envio rápido pelo servidor da web. O resultado é que o espaço é economizado (já que as imagens são criadas apenas quando necessário) e o upload de imagens é muito mais rápido (já que não está mais gerando as imagens no upload).

Coloque isso no arquivo de funções do tema. Isso impedirá o Wordpress de criar qualquer coisa, exceto os três tamanhos padrão ao fazer o upload.

Quando uma imagem é solicitada em um tamanho específico, que ainda não foi gerado, ela será criada apenas uma 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']
            );
        }

Infelizmente, a resposta de @ Patrick quebra as funções srcset introduzidas no WP 4.4. Felizmente, precisamos apenas adicionar duas funções adicionais!

Primeiro, precisamos reintroduzir temporariamente todos os tamanhos de miniatura registrados nos metadados da imagem para que possam 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);

Em seguida, precisamos executar as correspondências e gerar as miniaturas ausentes:

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

Na verdade, add_image_size()não gera a miniatura, apenas registra o tamanho da imagem disponível para o WordPress.

Normalmente, as miniaturas são geradas quando a imagem é carregada pela primeira vez. É um processo automático, assim você não precisa se preocupar em gerá-los mais tarde. Pense dessa maneira - se forem necessários 1-2s para gerar uma miniatura em um servidor lento e você esperar até que seja solicitado, forçará o solicitante a esperar 1-2s adicionais por imagem para ver o conteúdo. É muito mais fácil fazer isso com antecedência - ou seja, quando a imagem é carregada.

Ao mesmo tempo, se você precisar absolutamente processar as miniaturas em um momento diferente, consulte o plug-in Regenerate Thumbnails do Viper . Ele usa uma ação sob demanda para regenerar todas as miniaturas de imagens ... mas você pode usar código semelhante para gerar miniaturas apenas quando necessário.

Existe uma maneira de disparar add_image_size somente quando necessário?

Não exatamente. Mas você pode filtrar a lista de tamanhos registrados antes de as miniaturas serem geradas. A função wp_generate_attachment_metadata () (que chama a função que gera as miniaturas) possui um filtro chamado "imagem_ intermediária_de_tamanho_advanced", que permite manipular a matriz de tamanhos imediatamente antes da geração dos arquivos. Você pode usar esse filtro sempre que adicionar uma imagem de um "tipo" específico e removê-lo imediatamente depois.

Acho que seu maior desafio seria descobrir como diferenciar imagens que precisam de tamanhos extras e aquelas que não precisam.

Você pode usar meu plug-in (não Ottos) "Dynamic Image Resize" ¹⁾ .

O “Dynamic Image Resize” é um plug-in do WordPress (MU-) que oferece um código de acesso e uma tag de modelo para redimensionar as imagens “em andamento” sem a necessidade do TimThumb, mas com as principais funções do WP.

O plug-in vem com uma tag de modelo e um código de acesso também.

^{1) Acabei de descobrir sobre o plugin Ottos. A colisão de nomes não foi intencional.}

Você pode experimentar este plugin: https://wordpress.org/plugins/optimize-images-resizing

Ele redimensiona as imagens com base no tamanho da imagem registrada, mas somente quando necessário. Também pode limpar os tamanhos de imagem existentes para que eles possam se regenerar.

O plug-in WP Performance Pack oferece "manipulação de imagem aprimorada", baseada no Ottos Dynamic Image Resizer, mas inclui muitas melhorias, por exemplo: Antes de tudo, é compatível com a versão mais recente do WordPress (3.9.1), usa WP_Image_Editor, economizando miniaturas pode desativado (mas eles podem ser armazenados em cache e o Suporte CDN está a caminho), regenerar a integração do Thumbails (para excluir as miniaturas existentes) e muito mais.

Você também pode tentar o Aqua Resizer - https://github.com/syamilmj/Aqua-Resizer/

É apenas um arquivo.

Você pode usá-lo assim:

$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

Aqui está outra abordagem: ela se prende ao tratamento de erros HTTP 404. Ou seja, quando a miniatura não estiver disponível, localize a imagem original e crie a miniatura. Observe que isso realmente não resolve o seu problema, pois não impede a geração de miniaturas durante o upload.

Observe também que esse plug-in pode ser usado por usuários mal-intencionados para criar qualquer número de miniaturas e, assim, esgotar o espaço em disco.

Nota: Este plugin pode ser facilmente instalado usando o 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();
}