none
GetThumbnailImage é muito lento... quais sao as outras opçoes? RRS feed

  • Pergunta

  • Olá pessoal,

    Estamos desenvolvento um visualizador de imagens estilo ACDSEE ou Infraview. O fato é que trabalhamos com uma base de 5000 imagens diárias.

    É claro que isso nao é carregado tudo de uma vez na memoria, somente 30 imagens sao carrgadas por pagina.... o problema que eu vejo é que o metodo nativo  GetthumbnailImage demora cerca de 1 segundo para tratar cada imagem, entao 30 imagens, 30 segundos, o que é inaceitavel.

    O codigo é mais ou menos este:

     public Image ResizeImage(Image bmpOriginal, int newWidth, int newHeight)
            {
                return bmpOriginal.GetThumbnailImage(newWidth, newHeight, null, IntPtr.Zero);
    
            }

    Eu tenho um panel com 30 picturebox (esse numero é fixo), e para visualizar a imagem eu faço:

     for (int i = 0 ; i < 30 ; i++)
                {
    
     ((PictureBoxExtended)flow.Controls[i] ).Image =                    ResizeImage(Image.FromFile(pics[(page) + i].filename), DIMENSION, DIMENSION);
                }

    onde a coleçao pics contem o nome do arquivo.

    Como vcs podem notar nao há nada de complexo, mas o processo é extremamente lento...

    Nao é o tempo de caraga da imagem que é o gargalo... Fizemos um teste lendo somente uma imagem e o tempo foi pratimanente o mesmo:

    Image img = Image.FromFile(pics[1].filename);
     for (int i = 0 ; i < 30 ; i++)
                {
    
     ((PictureBoxExtended)flow.Controls[i] ).Image =                    ResizeImage(img, DIMENSION, DIMENSION);
                }

    Se o metodo resizeImage é retirado, praticamente a exibiçao é instantanea, mas neste caso as imagems sao cortadas e nao reduzidas... Detalhe: utilizar a propriedade strech do picture box tem o mesmo efeito do getthumbail...

    Outra soluçao foi usar o DrawImage, ajustando o tamanho da nova imagem ao tamanho desejado, mas em termos de performance é igual.

    Nao podemos utilizar WPF no momento. Entao resta duas soluçoes: ou usar GDI ao inves de GDI+ ou usar DirectX... nenhuma dessas duas soluçoes sao triviais.

    Alguem tem uma ideia (com codigo se possivel) de como acelerar a criaçao de thumbnails?

    Grato pela atençao de todos.



    William John Adam Trindade
    Analyste-programmeur
    ----------------------------------------------------------


    quinta-feira, 17 de abril de 2014 16:10
    Moderador

Todas as Respostas

  • Olá,

    Isso é aplicação Win Forms?


    Herbert Lausmann

    quinta-feira, 17 de abril de 2014 16:17
  • Ola Herbert,

    Sim.. é uma aplicaçao winforrms... como ira rodar ainda com windows XP, wpf nao é permitido... Direct2D sim.. mas nao consigo utilzar de uma forma estavel, apesar de parecer bem mais rapido.

    Grato


    William John Adam Trindade
    Analyste-programmeur
    ----------------------------------------------------------


    quinta-feira, 17 de abril de 2014 16:23
    Moderador
  • WPF também não iria adiantar grande coisa, mas eu tive uma ideia interessante...

    Tem uma API para processamento de Imagens, que é relativamente consagrada, escrita em C++ (Por isso possui bom desempenho).

    Se chama ImageMagick. O melhor de tudo é que existe um Wrapper para usa-la no .Net Framework sem problemas.

    Recomendo que você dê uma olhada:

    Magick.NET - Home


    Herbert Lausmann

    quinta-feira, 17 de abril de 2014 16:34
  • Ola.. Ja usamos o Magick em outro projeto c++.

    Realmente nao sabia que existia um wrapper para .net, pena que ainda esteja em alpha.

    Fiz um teste rapido, mas me parece que ainda esta longe de ser estavel.

    Usei a seguinte sintaxe para reduzir somente uma imagem:

    public Image ResizeImage(string bmpOriginal, int newWidth, int newHeight)
    {
                
       ImageMagick.MagickImage img =new ImageMagick.MagickImage(bmpOriginal);
       img.Resize(90, 90); //<---- erro aqui
       return img.ToBitmap();
    }


    e gerou esse erro:

    {"Attempted to read or write protected memory. This is often an indication that other memory is corrupt."}

    No momento eu nao consigo testar...

    Me certifiquei que era a ultima versao estavel.

    Voce ja usou essa biblioteca em .nET?


    William John Adam Trindade
    Analyste-programmeur
    ----------------------------------------------------------


    quinta-feira, 17 de abril de 2014 17:36
    Moderador
  • Eu particularmente nunca usei essa lib.

    Experimenta fazer assim:

    public Image ResizeImage(string bmpOriginal, int newWidth, int newHeight)
    {
                
       ImageMagick.MagickImage img =new ImageMagick.MagickImage();
       img.Read(bmpOriginal);
       img.Resize(90, 90);
       return img.ToBitmap();
    }

    Tecnicamente dá no mesmo, mas vai saber...

    E, apesar da lib ainda estar em Alpha, ela já está na versão 6.8.8 e é atualizada com frequência, então talvez não seja um bug.

    No objeto MagickImage não tem nenhum método Unlock, Unfreeze, ou algo do gênero? Se tiver, tente chamar ele antes de dar o Resize...


    Herbert Lausmann

    quinta-feira, 17 de abril de 2014 18:03
  • Sim.. mesmo erro.

    >No objeto MagickImage não tem nenhum método Unlock, Unfreeze, ou algo do gênero? Se tiver, tente chamar ele antes de dar o Resize...

    Como quase todo projeto aberto, a documentaçao é péssima... Inclusive eu encontro exemplos no site que nao funcionam mais, porque eles mudaram o nome de certas coleçoes e interfaces.

    Ja postei uma questao no forum do imagemagik com um test case.

    Alguma outra ideia?


    William John Adam Trindade
    Analyste-programmeur
    ----------------------------------------------------------

    quinta-feira, 17 de abril de 2014 19:38
    Moderador
  • Olá William, acredito que esse é um problema antigo, já fiz algo parecido só que eu usei calculo mesmo, ou seja

    aumentava e diminuia a imagem de acordo com que o usuario pedia proporcionalmente largura e altura, com as imagens de até 1mb ficou muito bom, agora com as imagens acima disso ficou lento também, pode ser um bom teste tentar assim, mas se as imagens for maior que 2mb também não vai ficar bom...

    quinta-feira, 17 de abril de 2014 19:49
  • Minhas imagens tem em media 500k. Sao resultado de um scanner de documentos, ou seja a maioria é jpg em tons de cinza, apesar de terem dimençoes grandes (2600 x 4000)

    Grato pela atençao


    William John Adam Trindade
    Analyste-programmeur
    ----------------------------------------------------------

    quinta-feira, 17 de abril de 2014 19:56
    Moderador
  • Minhas imagens tem em media 500k. Sao resultado de um scanner de documentos, ou seja a maioria é jpg em tons de cinza, apesar de terem dimençoes grandes (2600 x 4000)

    Grato pela atençao


    William John Adam Trindade
    Analyste-programmeur
    ----------------------------------------------------------

    Tenho mais três sugestões:

    Usar o DirectX, é muito semelhante ao WPF a parte dos bitmaps. Existe um projeto de código aberto chamado SharpDX que wrappa (Ah eu não sei o termo correto, é do verbo Wrap) toda a API do DirectX para o .NET. Essa API faz isso na integra, então a documentação da Microsoft serve como referência.

    SharpDX - Managed DirectX

    Usar alguma engine de games! Soa estranho, mas como para os games o desempenho máximo é muito importante, é provável que algum motor de jogo por aí tenha métodos para realizar este procedimento da forma mais otimizada possível.

    Usar outra Lib específica para manipulação de imagens. Tem várias outras escritas em C/C++, só o problema é que não tem Wrapper para .NET, então será necessário fazer P/Invoke na marra mesmo. Tem uma pequena lista de libs aqui:

    Fast Cross-Platform C/C++ Image Processing Libraries - Stack Overflow

    Teve um maluco que escreveu um artigo no Codeproject com código em C++ para fazer o redimensionamento de imagens de forma rápida. Talvez seja uma opção também:

    2D Fast Wavelet Transform Library for Image Processing - CodeProject


    Herbert Lausmann

    sexta-feira, 18 de abril de 2014 14:08
  • Vamos lá:

    Usar o DirectX, é muito semelhante ao WPF a parte dos bitmaps. Existe um projeto de código aberto chamado SharpDX que wrappa (Ah eu não sei o termo correto, é do verbo Wrap) toda a API do DirectX para o .NET. Essa API faz isso na integra, então a documentação da Microsoft serve como referência.

    SharpDX - Managed DirectX

    Estou fazendo experiencias com essa biblioteca.. minha difuculdade esta em conseguir faze-la funcionar. Nao existe um tutorial simples de como reduzir uma imagem. Eu acho toneladas de documentaçao sobre o Direct3D, mas direct2D  usando o SharpDX ta dificil.

    Usar alguma engine de games! Soa estranho, mas como para os games o desempenho máximo é muito importante, é provável que algum motor de jogo por aí tenha métodos para realizar este procedimento da forma mais otimizada possível.

    Sim.. O problema é sempre a estabilidade.. nao posso usar nada que dependa especificamente da GPU.. Pode ser que funcione com alguns micros e nao funcione em outros... Mas pelo que eu vi o mundo se resume ou a DirectX ou a OpenGL.

    Usar outra Lib específica para manipulação de imagens. Tem várias outras escritas em C/C++, só o problema é que não tem Wrapper para .NET, então será necessário fazer P/Invoke na marra mesmo. Tem uma pequena lista de libs aqui:

    Fast Cross-Platform C/C++ Image Processing Libraries - Stack Overflow

    O problema é cair em desenvolvimento C++.. Convenhamos que o projeto fica bem mais complexo e caro, principalmente pelo fato que nós temos que integrar noss interface com um banco de dados.. Pelo que eu vi na documentaçao C++ isso começa a ficar caro em termos de tempo de desenvolvimento.

    >Teve um maluco que escreveu um artigo no Codeproject com código em C++ para fazer o redimensionamento de imagens de forma rápida. Talvez seja uma opção também:

    2D Fast Wavelet Transform Library for Image Processing - CodeProject

    Sim. Eu ja tinha pensado em criar algo usando wavelets.. Mas o problema é a GDI+.. Em algum momento vc cai em um get/setpixel e isso é lento com GDI+.

    Obrigado.. caso tenha algum exemplo funcional com SharpDX, me diga... Tudo o que eu faço com essa biblioteca da crash.


    William John Adam Trindade
    Analyste-programmeur
    ----------------------------------------------------------

    sexta-feira, 18 de abril de 2014 17:34
    Moderador
  • Desculpe, não tenho nenhum material que faça uso do SharpDX.

    Mas eu resolvi fazer uns testes com o GDI+. Usei este código:

                var watch = new System.Diagnostics.Stopwatch();
                watch.Start();
                Bitmap bmp = new Bitmap(@"C:\test.jpg");
                pictureBox1.Image = bmp.GetThumbnailImage(90, 90, null, IntPtr.Zero);
                watch.Stop();

    A imagem de teste possui 0,99 MB. Já a máquina onde testei, tem um processador Celeron 1.6 GHz, 512MB de RAM e roda Windows 7 Home Basic.

    Nesse cenário foram necessários apenas 350 milissegundos para a miniatura ser gerada e mostrada no PictureBox.

    Eu realmente não entendi isso. Era para ter demorado mais tempo. Fora que, segundo a documentação, o método GetThumbnailImage é otimizado para ser a forma mais rápida do GDI+. Testei na prática, usando outras formas:

            private void button2_Click(object sender, EventArgs e)
            {
                var watch = new System.Diagnostics.Stopwatch();
                watch.Start();
                Bitmap bmp = new Bitmap(@"C:\test.jpg");
                pictureBox1.Image = FastestBitmapResize2(bmp, 90, 90);
                watch.Stop();
                label1.Text = watch.ElapsedMilliseconds.ToString();
            }
    
            public Bitmap FastestBitmapResize(Bitmap source, int newWidth, int newHeight)
            {
                Bitmap bmp = new Bitmap(source, newWidth, newHeight);
                return bmp;
            }
    
            public Bitmap FastestBitmapResize2(Bitmap source, int newWidth, int newHeight)
            {
                Bitmap bmp = new Bitmap(newWidth, newHeight);
                using (Graphics gr = Graphics.FromImage(bmp))
                {
                    gr.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.Low;
                    gr.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy;
                    gr.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighSpeed;
                    gr.DrawImage(source, 0, 0, newWidth, newHeight);
                }
                return bmp;
            }

    Essas se mostraram 2+- vezes mais lentas que o método GetThumbnailImage. Mesmo configurando o objeto Graphics para ser o mais rápido possível.

    Teoricamente era para o GDI+ ser a melhor opção no seu caso, já que ele é escrito em C++...

    Sem falar que o DirectX e semelhantes podem se tornar mais lentos em uma máquina que não possui uma boa GPU, sendo assim uma API que foque na CPU e eventualmente na GPU seria a melhor opção.

    Agora, será que colocar uma chamada para o método Application.DoEvents() em cada iteração do For não melhore o desempenho geral?


    Herbert Lausmann

    sexta-feira, 18 de abril de 2014 20:29
  • Eu creio que eu sei o porque... No seu caso pode ser que o jpg gerado tenha um thumbnail incorporado.. É comum em alguma maquinas fotograficas incorporarem um thumbail na imagem no momento da criaçao do JPG... Se for esse o caso o que vc esta vendo é o tempo de carregamento desse thumnail e nao da criaçao de um.

    No nosso caso esse thumbnail nao existe.

    Outra armadilha é que as vezes o thumbnail incorporado esta corrompido o que faz ficar mais lento ainda..

    Faça um teste com um BMP ao inves de um JPG... Ai vc vair ter o tempo real.

    Mas 350 ainda é lento... Veja 3 imagens demorariam 1 segundo. 30 Seriam 10 segundos...

    Nosso tempo alvo seria em torno de 2 segundos para as 30 o que dá 70ms por imagem.. eu sei que isso é possivel pois o ACDSEE consegue.. eu tambem sei que ACDSEE é escrito em C++, mas quero esgotar todas as possibilidades com o .NET antes de mudar a linguagem de programaçao, mesmo porque a parte que faz a integraçao com o banco de dados ja esta pronta. 

    Estou tentando ainda a idéia do imagemagick. Ja usamos essa biblioteca e ela realmente é rapida... gostaria somente que ela fosse mais estavel em .NET.

    Grato


    William John Adam Trindade
    Analyste-programmeur
    ----------------------------------------------------------



    sábado, 19 de abril de 2014 21:26
    Moderador
  • É eu tinha lido a respeito de miniaturas que vêm incorporadas na imagem...

    Mas 70ms para criar e mostrar uma miniatura em .NET? Com muito suor você consegue um 150ms, agora 70 eu acho difícil. Pois usando o método GetThumbnail para retornar a miniatura que vem incorporada em uma imagem Jpeg a média é 120ms, pelo menos aqui. Mas são 120ms para carregar uma imagem que já está redimensionada.

    O Wrapper da ImageMagick é apenas uma coleção de P/Invoke, structs e classes para se comunicar com a lib em C++. E P/Invoke não é a coisa mais veloz, as partes que fazem uso de Marshal se tornam lentas.

    Acho que você conseguiria algo otimizado dessa forma:

    Esquece o Wrapper da ImageMagick! Cria uma DLL em C++ e linka ela pra a ImageMagick. Aí tu cria uma função que possui um parâmetro char* (ou é *char ? um ponteiro para uma string (char[])). Essa função realiza o carregamento do Bitmap usando a ImageMagick, redimensiona e retorna um byte[] com os bytes da imagem redimensionada.

    No .NET você cria a chamada para essa função usando P/ Invoke. Aí toda vez que for necessário gerar uma miniatura de uma imagem em disco, você chama essa função passando o caminho da imagem como parâmetro. Ela irá retornar o array de bytes da imagem redimensionada. Aí é só instanciar um MemoryStream com estes bytes e criar um bitmap assim: Bitmap bmp = new Bitmap(memoryStream);

    Penso que assim se conseguiria um bom desempenho, e eliminaria a instabilidade do Wrapper da ImageMagick para .NET fazendo tudo direto com a lib. É só mais uma ideia...


    Herbert Lausmann

    domingo, 20 de abril de 2014 11:51
  • O problema de instabilidade com o ImageMagick.net era uma atualizaçao do driver da minha plca de video.

    Desintalei e instalei o original, mas o imagemagick.net é bem mais lento que o getthumbailimage...

    Agora com a atualizaçao (na verdade desatualizaçao) eu chegei perto dos 200ms com o getthumbnail, mas o imagemagick fica sempre perto dos 700ms.

    Estou tentado fazer um teste com uma dll em C++ et invoke. Alguem  ja fez isso?

    Procurando um pouco eu achei este artigo:

    http://msdn.microsoft.com/fr-fr/library/bb469896.aspx

    Tentei achar como o Windows Explorer cria seus thumbnails, mas nao encontrei a API. Achei varios artigos que falam de ler o thumbs.db mas nao é o meu caso... O que eu preciso é criar o thumbnail de forma bem rapida.



    William John Adam Trindade
    Analyste-programmeur
    ----------------------------------------------------------




    terça-feira, 22 de abril de 2014 12:48
    Moderador
  • Olá William,

    Conseguiu algum progresso?


    Herbert Lausmann

    quarta-feira, 30 de abril de 2014 21:17
  • Nao ainda... Após ler esse artigo:

    http://superuser.com/questions/315885/fast-batch-image-resizer

    vi que realmente o ImageMagick é lento (ele é flexivel no quesito manipulaçao de imagens com varias opçoes mas nao foi feito para ser rapido).. Testei o ImageResizer (este sim foi feito levando em conta a velocidade), mas mesmo assim é lento... abaixo do que ACDSEE e o Windows Explorer conseguem fazer.

    Quando eu digo lento, quero dizer que todas as minhas 5000 mil imagens levaram 24 minutos para ser criadas. Ou seja 3 imagens/segundo (320 ms  por imagem) em uma maquina normal... No meu computador pessoal (que tem um disco SSD) esse tempo cai para 4 minutos (20 imagens/seg ou 48ms/imagem). Mas esse é o tempo que o ACDSEE leva para exibir em um computador normal (digo com um HD 5400)

    Lembrando que uma vez que os thumbnails criados fisicamente o visualizador é extremamente rapido. O gargalo é realmente a redimensionamento da imagem.

    grato


    William John Adam Trindade
    Analyste-programmeur
    ----------------------------------------------------------



    quinta-feira, 1 de maio de 2014 15:19
    Moderador
  • Eu encontrei uma lib C++ chamada ArrayFire. Segundo a documentação, ela prima pela velocidade, através de CUDA e OpenCL.

    Pelo que eu li na documentação, carregar e redimensionar imagens (jpeg, png, bmp e tiff) é fácil. Só não consegui enxergar como fazer a interoperabilidade dessa lib com .NET.

    O problema maior, na minha opinião, é a interoperabilidade. Linguagem Gerenciada não vai conseguir esse desempenho para redimensionar, logo é necessário usar alguma Lib em C/C++. O problema é como puxar pro C# o bitmap que está carregado em uma instância de uma classe C++? Se ao menos essas libs disponibilizassem uma forma de acessar o array de bytes da imagem redimensionada, já seria alguma coisa, mas nem todas dão essa possibilidade...

    A API tida como mais otimizada é a Intel® Integrated Performance Primitives (Intel® IPP), mas é paga ($199,00)...

    Talvez seja necessário escrever um código em C#/C/C++ para fazer o redimensionamento. Sobre essa parte indesejável, eu localizei isso:

    http://code.google.com/a/eclipselabs.org/p/bicubic-interpolation-image-processing/source/browse/trunk/libimage.c

    Quick image scaling algorithms

    Parece que a Aforge.Net tem algoritmos otimizados para essas coisas:

    http://www.aforgenet.com/framework/docs/

    Realmente, é uma tarefa um pouco complexa...


    Herbert Lausmann

    quinta-feira, 1 de maio de 2014 17:06
  • Eu uso Aforge.NET e é lento tambem... mas seu artigo sobre metodos em c++ me deu algumas idéias...

    Quick image scaling algorithms

    Estou evitando ao maximo usar C++. Queria realmente esgotar todas as possibilidades de trabalhar com C# (mesmo que fosse usando unsafe code).

    Quanto a IPP eu ja tinha olhado.. o problema nao é o preço.. 199 é barato aqui no Canada e o cliente pagaria sem problemas.. O problema  a integraçao com C# e  para converter todo o projeto em C++ vai custar muito caro. Fazer uma soluçao mista (meio c# meio c++) pode sair mais caro ou mais barato (depende de quanto integravel for)

    Nao posso usar CUDA.. Pelo que eu li CUDA é somnete para placas Nvidia... Nao posso por essa limitaçao no software. Quanto a OpenCL eu caio no memso problema do DirectX... Eu nao estou conseguindo fazer funcionar de forma generica.

    Ainda gostaria de identificar o metodo usado pelo Windows Explorer para criar seus thumbnails.. Nao acho documentaçao em lugar nenhum. 

    Obrigado pela atençao... Vou fazer alguns testes com a IPP. Caso outra ideia surja, podem postar.. no final eu posto publicamente os codigos das minhas tentativas.

    Grato


    William John Adam Trindade
    Analyste-programmeur
    ----------------------------------------------------------

    quinta-feira, 1 de maio de 2014 17:37
    Moderador
  • Diz uma coisa, o sistema do cliente é o XP SP3? Ou ainda é um SP2 ou mais antigo?

    Herbert Lausmann

    sexta-feira, 2 de maio de 2014 14:55
  • Tem clientes que vao rodar (ainda) em XP.. Eu uso Windows 7 964bits) no desenvolvimento e tenho uma maquina XP SP3 para testes.

    Estou fazendo alguns testes com C++.. Ainda nao estou habituado em programar com essa linguagem.. Eu programava em C++ no tempo da Borland.. mas visual C++ é novidade.

    Att


    William John Adam Trindade
    Analyste-programmeur
    ----------------------------------------------------------

    sexta-feira, 2 de maio de 2014 16:14
    Moderador
  • Very well hehe, pelo menos eu acho...

    A partir do XP SP3 (SP2 talvez?) o Windows vem acompanhado do WIC (Windows Image Component). Inclusive é essa a API que o WPF usa para manipulação de imagens (Eu pensava que era a api do DirectX que ele usava...).

    Em todo caso, segue um trechinho que eu retirei da página do Windows(File) Explorer da Wikipédia:

    "Explorer can show a preview for any image format if the necessary codec for the format is installed in the Windows Imaging Component."

    Fonte: File Explorer - Wikipedia, the free encyclopedia

    Então, a partir disso é plausível presumir que o Windows usa o WIC para gerar os Thumbnails de imagens do Explorer. Com WIC é possível pegar a miniatura que eventualmente acompanha o arquivo e caso não haja nenhuma, é possível redimensionar a imagem somente usando o WIC.

    Em contrapartida, nesse post é possível ver um Benchmark comparando o GDI+ com o WIC:

    Resizing Images - WIC vs GDI - Stack Overflow

    Em contrapartida disso também, o cara usou a API do WPF para fazer os testes. Então, talvez, se usar diretamente a API do WIC os resultados sejam o inverso...

    Outra coisa que eu andei vendo é a influência do algoritmo de interpolação usado para redimensionar. Pelo que andei lendo seria mais ou menos assim:

    Nearest-neighbor interpolation = Ótimo desempenho, menor qualidade. Creio que este seja o melhor, afinal, estamos querendo gerar miniaturas, e em um tamanho pequeno não dá para se ver a perda de qualidade...

    Bilinear interpolation = Qualidade mediana, e desempenho mediano...

    Bicubic interpolation = Qualidade alta, e desempenho baixo...

    Pelo que eu vi na documentação do MSDN, o WIC suporta esses e outros:

    WICBitmapInterpolationMode enumeration (Windows)

    Fora o WIC e o GDI+, acho que não deve haver outra API que o Windows use para gerar thumbnails...


    Herbert Lausmann

    sexta-feira, 2 de maio de 2014 16:42
  • Sim.. Eu sei que o WIC (que é usado WPF) é muito mais rapido do que a GDI+. O que eu nao consegui fazer é usar WIC em uma aplicaçao Windows Forms.. Realmente eu pensava que o WIC estava somente disponivel no Windows 7/8.. Agora eu vi que a partir do framework 3 (mesmo para XP) ele esta disponivel

    Vou dar uma olhada novamente neste artigo:

    http://weblogs.asp.net/bleroy/archive/2009/12/10/resizing-images-from-the-server-using-wpf-wic-instead-of-gdi.aspx

    Note que as velocidades "WPF" sao bem mais rapidas do que a GDI.. mas isso eu preciso ver se roda no XP.

    Obrigado mais uma vez.



    William John Adam Trindade
    Analyste-programmeur
    ----------------------------------------------------------

    sexta-feira, 2 de maio de 2014 17:02
    Moderador
  • Muito interessante esse artigo, obrigado por compartilhar.

    Só fiquei em dúvida com uma coisa: o método Resize, descrito no artigo, faz uso da classe DrawingVisual. Não tenho certeza, mas eu acho que essa classe faz uso, internamente, de alguma interface/classe do DirectX...

    Já a API pura do WIC (em C++), permite o redimensionamento de imagens de forma direta, sem DirectX e outras APIs externas, inclusive dando a opção de escolha da interpolação.

    Não tenho certeza se o DrawingVisual faz mesmo uso do DirectX, mas é provável...


    Herbert Lausmann

    sexta-feira, 2 de maio de 2014 23:42