[C#] Conversor de imagens ...

[mephisto]

Code Select Expand

/*
    * Componente    : Conversor de Imagens
    * Data Criação  : 21 - 06 - 2008
    * Desenvolvedor : Ricardo S. de Barros
   
    * Propósito     : Necessidade de redimensionar imagens, para processar em dispositivo PocketPC
                      o componente recebe a imagem em qualquer formato e converte para outro qualquer
                      em que ao fim a estrutura binária seja menor do que o original ficando com tamanho
                      em bytes muito menor facilitando envio/recebimento PocketPC <-> Servidor.
                     
*/

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Text;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Windows.Forms;
using System.IO;

namespace ConversorImagem
{
    public partial class ConversorImg : Component
    {
        #region Propriedades Internas

        private string m_sSaidaPadrao;
        private ImageFormat m_imgFormat;
        private bool bCompactar;
       
        #endregion

        #region Propriedades Publicas

        /// <summary>
        /// Propriedade que define o caminho que deverá ser a saída da imagem.
        /// </summary>
        public string SaidaPadrao
        {
            get { return m_sSaidaPadrao; }
            set { m_sSaidaPadrao = value; }
        }

        /// <summary>
        /// Propriedade que define o formato que a imagem deve ter após conversão.
        /// </summary>
        public ImageFormat FormatoImagem
        {
            get { return m_imgFormat; }
            set { m_imgFormat = value; }
        }

        #endregion

        #region Construtor

        /// <summary>
        /// Construtor do componente que identifica onde deverá sair os arquivos.
        /// </summary>
        public ConversorImg(string sSaida, ImageFormat FormatoDesejado)
        {
            InitializeComponent();

            // Aplico na propriedade a saída especificada ...
            if (sSaida.Trim().Length != 0) SaidaPadrao = sSaida;

            // Aplico também o formato escolhido por usuário.
            FormatoImagem = FormatoDesejado;
        }

        #endregion


        /// <summary>
        /// Método que realiza extração do nome original do arquivo para gravar
        /// na saída escolhida por usuário.
        /// </summary>
        /// <param name="sArquivoAlvo">Path completo do arquivo</param>
        /// <returns>Retorna nome original</returns>
        private string ExtraiNomeArquivo(string sArquivo)
        {
            string sAuxi = "";
            string sNomeOriginal = "";

            // Laço por todos os caracteres do path recebido ...
            for (int i = 0; i <= sArquivo.Length - 1; i++)
            {
                // Realizo pesquisa caracter a caracter até achar o '.' (ponto separador) de toda extensão.
                if (sArquivo[i] == '.')
                {
                    // Se encontrou, realizo um laço de trás pra frente para pegar do
                    // '.'(ponto separador) até a primeira '\'(barra) sendo assim
                    // no meio dos dois consigo o nome do arquivo.
                    for (int j = i; j >= 0; j--)
                    {
                        // Procuro a barra 'andando' de trás pra frente se achar
                        // a barra termina também ..
                        if (sArquivo[j] == '\\') break;

                        // Enquanto procuro vou armazenando o espaço do ponto até a barra pois esse já é o nome
                        // porem ele vai ficar invertido ...
                        sAuxi += sArquivo[j];
                    }

                    // Como o nome virá invertido como no 'espelho' rotaciono ele para ficar correto.
                    for (int k = sAuxi.Length - 1; k > 0; k--)
                        sNomeOriginal += sAuxi[k];

                    // Caso não ache por qualquer motivo a barra, então depois do laço inverso termino
                    break;
                }
            }

            // Retorno o nome extraído.
            return sNomeOriginal;
        }

        /// <summary>
        /// Método que realiza o algoritmo de conversão do arquivo. usando biblioteca GDI+ (.NET)
        /// </summary>
        public void Converter(string sArquivo, int iAltura, int iLargura)
        {
            PictureBox pctBuffer = null;
            Image imgAux = null;
            Bitmap bmpAux = null;
            string sCaminho = "";
            string sExtensao = "";
            string sNome = "";

            try
            {
                // Transformo a imagem do caminho recebido em um buffer para utilizar depois.
                // utilizando um picturebox auxiliar ...
                pctBuffer = new PictureBox();
                pctBuffer.ImageLocation = sArquivo;

                // Carrego a imagem recebida. e envio a um objeto image para tratar.
                pctBuffer.Load();
                imgAux = pctBuffer.Image;

                // Com o image (Array Bytes) formado transformo em um bitmap para conversão.
                // Seto o tamanho final que ela deverá ficar.
                bmpAux = new Bitmap(imgAux, iAltura, iLargura);

                // Se a conversão foi sucedida ...
                if (bmpAux != null)
                {
                    // Chamo método que realiza extração do nome do arquivo para salvar no disco.
                    sNome = this.ExtraiNomeArquivo(sArquivo);

                    // Valido o formato escolhido, e atribuo a extensão apropriada ...
                    if(FormatoImagem == ImageFormat.Bmp) sExtensao = ".bmp";
                    if(FormatoImagem == ImageFormat.Jpeg) sExtensao = ".jpg";
                    if(FormatoImagem == ImageFormat.Png) sExtensao = ".png";
                   
                    // Formato o caminho que será salvo.
                    sCaminho = String.Format("{0}{1}.{2}", SaidaPadrao, sNome, sExtensao);

                    // Salvo a imagem no caminho recebido no construtor. com o nome que ela veio
                    // e com sua nova estrutura binária seja bmp/jpg/png.
                    bmpAux.Save(sCaminho, FormatoImagem);
                }
            }
            catch (Exception err)
            {
                MessageBox.Show(String.Format("Ocorreu um erro no componente {0}", err.Message), "Atenção");               
            }
            finally
            {
                // Libero memória alocada.
                if (pctBuffer != null) pctBuffer.Dispose();
                if (imgAux != null) imgAux.Dispose();
                if (bmpAux != null) bmpAux.Dispose();
            }
        }
    }
}
Boa noite. vou contribuir com algo em memória dos velhos tempos. quem for veterano aqui irá entender. 

Abraços.
[]s.