Como gerar miniaturas apenas quando necessário?

15

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

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

Obrigado

UPDATE Como você mencionou, não é realmente add_image_size o que precisa ser acionado. O que seria ótimo é disparar o redimensionamento da imagem quando eu uso the_post_thumbnail ('slider-thumb'); Talvez esta desaceleração a primeira vista da imagem, mas essa visão é geralmente gerada por mim quando eu realmente rever o post, então eu não me importo.

Então, entre minhas postagens, slider, miniaturas de blog, miniaturas de portfólio, etc, 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 das miniaturas das outras 990 imagens.

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

    
por chifliiiii 25.05.2012 / 23:52

10 respostas

11

Dê uma olhada no plugin do Dynamic Image Resizer de Otto

  

Este plugin muda a maneira como o WordPress cria imagens para torná-lo   gerar as imagens apenas quando elas são realmente usadas em algum lugar, no   mosca. Imagens criadas desta forma serão salvas no upload normal   diretórios, para posterior envio rápido pelo servidor web. O resultado é   esse espaço é salvo (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á gerando as imagens   no upload mais).

    
por Chris_O 26.05.2012 / 01:42
5

Coloque isso no arquivo de funções do seu tema. Isso impedirá que o Wordpress crie nada além dos 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']
            );
        }
    
por Patrick 28.11.2013 / 16:40
2

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 percorrer as correspondências e gerar 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);
    
por Josh 16.04.2016 / 07:08
1

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

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

Ao mesmo tempo, se você absolutamente precisa processar as miniaturas em um horário diferente, você pode querer dar uma olhada em Plugin Regenerar Miniaturas da Viper . Ele usa uma ação sob demanda para regenerar todas suas miniaturas de imagens ... mas você pode usar código semelhante para gerar miniaturas apenas quando necessário.

    
por EAMann 26.05.2012 / 00:07
1
  

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

Não exatamente. Mas você pode filtrar a lista de tamanhos registrados logo antes de gerar as miniaturas. A função wp_generate_attachment_metadata () (que chama a função que gera as miniaturas) tem um filtro chamado "intermediate_image_sizes_advanced", que permite manipular a matriz de tamanhos antes que os arquivos sejam gerados. Você pode usar esse filtro sempre que estiver adicionando uma imagem de um determinado "tipo" e, em seguida, removê-lo imediatamente após.

Acho que seu maior desafio seria descobrir como diferenciar entre as imagens que precisam dos tamanhos extras e as que não precisam.

    
por MathSmath 26.05.2012 / 00:27
1

Você pode usar meu (não Ottos) "Redimensionamento dinâmico de imagem" 1) plugin.

  

“Dynamic Image Resize” é um plugin para WordPress (MU-) que oferece um shortcode e uma tag de template para redimensionar imagens “on the flight” sem a necessidade do TimThumb, mas com funções principais do WP.

O plug-in vem com uma tag de modelo e um shortcode também.

1) Acabei de descobrir sobre o plugin Ottos. A colisão de nomes não foi planejada.

    
por kaiser 29.06.2013 / 13:03
1

Você pode experimentar este plug-in: enlace

Redimensiona imagens com base no tamanho da sua imagem registrada, mas apenas quando necessário. Também pode limpar tamanhos de imagens existentes para que eles possam gerar novamente.

    
por user2128576 30.07.2015 / 02:27
0
O plugin

WP Performance Pack oferece "melhor manuseio de imagem", que é baseado 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, salvar miniaturas pode ser desativado (mas elas podem ser armazenadas em cache e o CDN Support é on ist), Regenerate Thumbails integração (para excluir miniaturas existentes) e um pouco mais.

    
por Björn 14.05.2014 / 12:02
-1

Você também pode tentar o Aqua Resizer - enlace

É 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
    
por antongorodezkiy 17.03.2014 / 12:30
-1

Aqui ainda uma outra abordagem: Ele se conecta ao tratamento de erro 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 problema, pois não impede a geração de miniaturas durante o upload.

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

Observação: este plug-in 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();
}
    
por Jack Miller 22.05.2016 / 07:16