Introdução
Recentemente trabalhando num projeto ASP.NET, deparei-me com um cenário bastante específico que levou-me à buscar uma solução dinâmica que gostaria de compartilhar com vocês neste artigo. Você aprenderá como utilizar os Namespaces System.Drawing e System.Drawing.Imaging para converter imagens no formato TIFF Multiframes para JPEG, e ainda como inserir marcas d’água na imagem final.
O cenário
Nossa solução Web deveria permitir a consulta de documentos digitalizados no formato TIFF e permitir que o usuário navegasse através das frames (páginas) contidas no arquivo de imagem. Todos sabemos que o formato TIFF não é suportado naturalmente pelos browsers. Encontrei diversos componentes para suportar a exibição de imagens TIFF em páginas web, alguns pagos outros gratuitos, mas nenhum deles oferecia a flexibilidade necessária para nossa solução.
Outro problema que tínhamos referia-se à proteção das imagens dos documentos, por tratarem-se de documentos legais, a instituição que nos contratou fez uma exigência de que todas as imagens deveriam ser modificadas para incluir uma marca d’água que indicasse claramente que aquela imagem não poderia ser utilizada como um documento oficial.
Tínhamos ainda outros fatores complicadores. O número de arquivos de imagens que deveríamos converter e publicar estava próximo de 130.000 (cerca de 15GB) e crescendo a cada dia. Além disso, as imagens já existentes poderiam ser modificadas para receber uma nova página ou alterar uma página do documento original, desta forma nossa solução deveria prover um mecanismo para processar as imagens alteradas. Mais um detalhe importante, o sistema de gestão responsável por gerar as imagens digitalizadas em TIFF, por razões de performance, distribuia os arquivos gerados em pastas contendo no máximo 1000 arquivos em cada pasta, isto representava mais um fator a ser considerado, a solução deveria percorrer todas as pastas criadas pelo sistema de gestão, localizar as novas imagens e as imagens que sofreram alterações para processá-las e disponibilizá-las para publicação.
Analisando o problema
Após uma análise inicial, descartamos duas hipóteses:
a) Converter as imagens durante o processo de pesquisa, ou seja, o usuário entra na página de pesquisa informa o critério de busca e a aplicação localiza a imagem em seu estado original, realiza a conversão para JPEG, adiciona a marca d’água e exibe a imagem resultante para o usuário. Esta hipótese foi descartada porque a performance para consulta de cada imagem apresentou-se excessivamente prejudicada.
b) Outra hipótese era convertermos todas as imagens e inserir as marcas d’água diariamente num processo executado em horários extraordinários, esta hipótese não exigiria a identificação de imagens modificadas, uma vez que o processo seria aplicado para todas as imagens existentes mantendo-as atualizadas para publicação. Esta hipótese também foi descartada porque o processo de conversão e inserção das marcas d’água nas 130.000 imagens exigia várias horas para processamento, o que era enviável além de representar um fator de risco, pois processos longos executados sem interação do usuário estão sujeitos à diversos fatores que podem interromper o processamento e tornar o conjunto de imagens inconsistente.
A solução proposta
Após descartarmos as hipóteses anteriores, nossa solução foi implementada considerando as seguintes etapas:
a) Um processamento completo, ou seja, todas as 130.000 imagens, foi realizado no momento de implantação da solução. As imagens resultantes, já no formato JPEG e com a marca d’água foram disponibilizadas no servidor Web para consultas.
b) Criamos um componente para rastrear o pasta principal onde o sistema de gestão da instituição gera as imagens no formato original (TIFF). Esse processo de rastreamento é executado diariamente em horário agendado pelo usuário. O processo consiste em percorrer todas as subpastas em busca de novos arquivos de imagens ou arquivos modificados após a última publicação. Esta busca foi implementada utilizando o Namespace System.IO com o uso das classes FileInfo e DirectoryInfo. A configuração deste componente foi facilitada com uma interface criada com Windows Forms. Esta interface permite ao usuário definir o horário de execução, periodicidade (diária, semanal, mensal), a pasta raiz que deverá ser rastreada, além de permitir outras configurações como a definição do texto que é inserido como marca d’água e a taxa de compactação do arquivo JPEG gerado (necessário para que o arquivo tenha tamanho adequado para Web).
c) Os testes de performance desta solução apresentaram resultados positivos. O processo de rastreamento, conversão das imagens e inserção das marcas d’água (em arquivos novos e modificados) foi concluído pelo componente em exatos 9,7 minutos. Para realizarmos os testes, reproduzimos o cenário da instituição, criando 130 pastas, cada uma contendo 1.000 arquivos TIFF em diversos tamanhos (diferentes números de frames). Depois acrescentamos 40 novos arquivos (com data de criação diferente dos demais), esta quantidade (40) foi determinada pela média de novos arquivos gerados diariamente na instituição. Também modificamos outros 8 arquivos escolhidos aleatoriamente dentro de diferentes pastas, esta quantidade de arquivos modificados (8) também foi determinada pela média apurada diária apurada pela instituição.
Nota: Uma observação importante refere-se ao código apresentado neste exemplo. Ele inclui algumas linhas utilizadas para manipular dois controles ProgressBar, um para indicar as pastas e subpastas processadas e outro para indicar os arquivos processados. Contudo, o código apresentado neste exemplo é apenas um fragmento da aplicação principal. A implementação dos controles ProgressBar feita dentro da mesma thread prejudica sensivelmente a performance do processo. No nosso caso, o controle ProgressBar foi utilizado apenas durante os testes realizados na fase de desenvolvimento. O componente responsável pelo processamento, apesar de prover interface para configuração, ele próprio é executado sem interação do usuário através de um serviço do Windows e dispensa o uso de controles para notificar o usuário do sobre o processamento.
Os quadros a seguir apresentam o código necessário para esta implementação. Observe os comentários adicionados ao código para falicitar a compreensão dos procedimentos.
//Namespaces necessários para esta implementação
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
namespace WD5ImageTools
{
public class ImageTools
{
///
/// Este procedimento varre a pasta principal e
/// subpastas contidas no diretório root informado
/// em busca de arquivos TIFF para convertê-los
/// em JPEG. Para cada frame contida no arquivo TIFF
/// será gerado um arquivo JPEG.
///
///
/// Este parâmetro indica o diretório onde o
/// processo será iniciado.
///
private void ConvertImages(string root_path)
{
// variável utilizada para determinar o tempo de processamento
DateTime start = DateTime.Now;
// A classe DirectoryInfo permite o rastreamento de todas
// as subpastas contidas no diretório raiz.
DirectoryInfo di = new System.IO.DirectoryInfo(root_path);
// Notifica o usuário que o processamento está em andamento
Cursor.Current = Cursors.WaitCursor;
// Cria um array com as subpastas
DirectoryInfo[] dirs = di.GetDirectories();
// Contadores utilizados para registrar os arquivos processados
int iFolderCount = 0;
int iFilesRead = 0;
int iFilesConverted = 0;
// inicia o loop através das subpastas
foreach (DirectoryInfo diNext in dirs)
{
// define as propriedades para o controle ProgressBar
// este controle foi utilizado durante a fase de testes
// contudo a performance é sensivelmente prejudicada
// quando a implementação é feita de forma simples como
// neste exemplo. O correto neste caso seria a criação de
// threads separadas uma para o processo das imagens e outra
// para a atualização dos controles de feedback para o usuário
pbFolders.Minimum = 0;
pbFolders.Maximum = dirs.Length;
lblFolderCount.Text = dirs.Length.ToString();
// incrementa o contador de pastas
iFolderCount++;
// atualiza o controle ProgressBar
pbFolders.Value = iFolderCount;
// inicia o loop através de todos os arquivos contidos na
// pasta selecionada. A busca é filtrada pela extensão TIF
foreach (System.IO.FileInfo fi in diNext.GetFiles(”*.tif”))
{
// incrementa o contador de arquivos lidos
iFilesRead++;
// define as propriedades do controle ProgressBar
pbFiles.Minimum = 0;
pbFiles.Maximum = diNext.GetFiles().Length;
lblFileCount.Text = diNext.GetFiles().Length.ToString();
// atualiza o controle ProgressBar
pbFiles.Value = iFilesRead;
// teste lógico para verificar se o arquivo encontrado foi
// alterado/modificado após o último processamento.
// A propriedade LastWriteTime foi utilizada para realizar
// esta comparação. Neste exemplo, somente os arquivos
// modificados serão processados.
if (fi.LastWriteTime.ToShortDateString() ==
DateTime.Today.ToShortDateString())
{
// incrementa o contador de arquivos convertidos
iFilesConverted++;
// cria um objeto Bitmap a partir do arquivo TIFF
Bitmap tifImage = new Bitmap(fi.FullName);
// obtém o número de frames (páginas) contidas no TIFF
int count = tifImage.GetFrameCount(FrameDimension.Page);
// inicia o loop através das frames
for (int i = 0; i < count; i++)
{
// armazena o caminho e nome completo do novo
// arquivo de imagem no formato JPEG que será criado
// para cada frame encontrada. O nome do arquivo
// será constituido do nome original do arquivo TIFF
// + um número sequencial.
string sFile = fi.FullName.Substring(0,
fi.FullName.Length - 4) + "_" + i + ".jpg";
// seleciona uma frame por vez utilizando a variável
// i como indexador
tifImage.SelectActiveFrame(FrameDimension.Page, i);
// salva a imagem no formato JPEG, utilizando a
// propriedade ImageFormat
tifImage.Save(sFile, ImageFormat.Jpeg);
// invoca o procedimento InsertWatermark para
// adicionar a marca d'água passa como parâmetro o
// texto da marca d'água e o nome do novo arquivo
// JPEG que será compactado neste procedimento
InsertWatermark("DOCUMENTO NÃO É VÁLIDO", sFile);
}
// libera os recursos utilizados pelo objeto Bitmap
tifImage.Dispose();
tifImage = null;
}
}
}
// restaura o estado original do cursor
Cursor.Current = Cursors.Default;
// define o término do processamento
DateTime finish = DateTime.Now;
// exibe mensagem informando as estatísticas do processamento
MessageBox.Show("Conversão concluída! \nInício: [" +
start.ToString() + "] \nTérmino: [" + finish.ToString() + "]
\nPastas: [" + iFolderCount.ToString() + "] \nArquivos Processados:
[" + iFilesRead.ToString() + "] \nArquivos Convertidos: [" +
iFilesConverted.ToString() + "]" , "WD5 Image Converter",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
///
/// Procedimento de apoio utilizado para construir um
/// array com os encoders do arquivo de imagem
///
///
tipo de imagem “image/jpeg”
/// retorna a coleção de encoders da imagem
private static ImageCodecInfo GetEncoderInfo(String mimeType)
{
int j;
ImageCodecInfo[] encoders;
encoders = ImageCodecInfo.GetImageEncoders();
for (j = 0; j < encoders.Length; ++j)
{
if (encoders[j].MimeType == mimeType)
return encoders[j];
}
return null;
}
///
/// Procedimento utilizado para adicionar a marca d’água ao arquivo
/// JPEG. Neste caso a marca d’água é constituida de um texto informado
/// através do parâmetro sLine.
///
///
Texto para marca d’água
///
nome do arquivo que será processado
private void InsertWatermark(string sLine, string ImageFile)
{
// variáveis que definirão o tamanho da imagem
int width = 0;
int height = 0;
// define os brushes e fonts utilizados construir a marca d’água
SolidBrush letterBrush = new SolidBrush(Color.FromArgb(100, 255,
255, 255));
SolidBrush shadowBrush = new SolidBrush(Color.FromArgb(100, 0, 0,
0));
Font fontTitle = new Font(”Times New Roman”, 72, FontStyle.Bold);
// cria um objeto Image (System.Drawing.Imaging)
Image img = Image.FromFile(ImageFile);
// define o tamanho da imagem
width = img.Width;
height = img.Height;
// cria um novo objeto Bitmap que será utilizado para
// gerar a nova imagem com a marca d’água
Bitmap baseMap = new Bitmap(width,height);
// cria um objeto Graphics a partir do novo Bitmap
Graphics myGraphic = Graphics.FromImage(baseMap);
// o objeto StringFormat é utilizado para definir o posicionamento
// vertical da marca d’água
StringFormat stringFormat = new StringFormat();
stringFormat.FormatFlags = StringFormatFlags.DirectionVertical;
// cria a nova imagem com base nos parâmetros informados
myGraphic.DrawImage(img, 0, 0, width, height);
myGraphic.SmoothingMode =
System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
// propriedade RotateTransform usada para rotacionar a marca d’água
// -45º para que ela fique posicionada na diagonal da imagem
myGraphic.RotateTransform(-45);
// cria a marca d’água com sombreamento usando o parâmetro sLine
myGraphic.DrawString(sLine, fontTitle, shadowBrush, -850, 1000);
myGraphic.DrawString(sLine, fontTitle, letterBrush, -850, 1000);
// libera os recursos utilizados pelo objeto Image
img.Dispose();
img = null;
// cria um objeto encoder que será utilizado para compactar
// o arquivo JPEG. o objeto EncoderParameter recebe dois
// parâmetros (o objeto myEncoder e o percentual de compactação
// que pode variar entre 0 e 100
Encoder myEncoder = Encoder.Quality;
EncoderParameter myEncoderParameter;
EncoderParameters myEncoderParameters;
myEncoderParameters = new EncoderParameters(1);
// compacta o arquivo JPEG com qualidade de 5%. Adequado neste caso
// pois trata-se de documento de texto digitalizado.
myEncoderParameter = new EncoderParameter(myEncoder, 5L);
myEncoderParameters.Param[0] = myEncoderParameter;
// obtém a coleção de encoders do arquivo de imagem
ImageCodecInfo myImageCodecInfo;
myImageCodecInfo = GetEncoderInfo(”image/jpeg”);
// salva o arquivo sobrescrevendo o original com a nova imagem
// acrescida da marca d’água e compactada
baseMap.Save(ImageFile, myImageCodecInfo, myEncoderParameters);
// libera os recursos utilizados pelo objeto Bitmap
baseMap.Dispose();
baseMap = null;
}
}
}
Conclusão
Você pode acompanhar todos os passos necessários para utilização dos Namespaces System.Drawing e System.Drawing.Imaging para converter imagens TIFF Multiframes em arquivos JPEG. Como compactar as imagens JPEG utilizando os objetos Encoders. Também aprendeu como acrescentar marcas d’água aos seus arquivos de imagens. Não pare por aí, existem inúmeras funcionalidades associadas aos mesmos Namespaces. A conversão de imagens pode ser realizada para diversos formatos utilizando a propriedade ImageFormat. Consulte os links do artigo e aprenda um pouco mais sobre a manipulação de imagens com o Visual C# 2005.
Sem Comentários 
