Guardar y obtener Texto dentro de imagen como propiedad


Hoy les traigo dos funciones interesantes, que les servira mucho a aquellos que trabajan mucho con procesamiento de imagenes (jpg;jpeg;png;bmp;etc), sobre todo cuando necesitamos guardar descripciones o comentarios para cada imagen que queremos procesar.

Imaginense que tenemos una pagina web que ofrece productos y tenemos imagenes para cada uno de los productos, realizar rutinas que guarden la descripcion para cada imagen de cada producto nos puede acarrear mucho trabajo, sobre todo al momento de crear la logica para que se guarde en la base de datos y luego para leer cada registro y relacionarlo con cada una de las imagenes.

Pues bien, les traigo una solución fácil y practica con la que nos  evitaremos horas de desarrollo y consiste en guardar la descripción de cada imagen dentro de la misma imagen como un metatag o mas bien una propiedad.

El enlace para descargar el código de ejemplo, se encuentra al final del post.

Con este primer método puedes agregarle la descripción a una imagen creando una propiedad con la información deseada:
        
        ///         
        /// Método usado para entrar a las propiedades de una imagen 
        /// y crear una nueva propiedad con información personalizada
        ///         /// 
        /// 
        private void SetDescription(Image Pic, string NewDescription)
        {
            byte[] bDescription = new Byte[NewDescription.Length];

            // Se copia la descripcion dentro de un byte array
            for (int i = 0; i < NewDescription.Length; i++) bDescription[i] = (byte)NewDescription[i];

            //Descomentar para cargar la imgen como stream
            //System.Drawing.Image Pic = Image.FromStream(Filename);

            //Descomentar la siguiente linea si se desea trabajar con rutas de archivos
            // System.Drawing.Image Pic = Image.FromFile(Filename);

            //Si la imagen ya tiene la propiedad con el id especificado, se elimina esta propiedad de la imagen 
            //para crearla nuevamente
            if (Pic.PropertyItems.Any(p => p.Id == NuevaPropiedad)) Pic.RemovePropertyItem(NuevaPropiedad);

            //Se genera la nueva propiedad
            PropertyItem PropertyItems = (PropertyItem)FormatterServices.GetUninitializedObject(typeof(PropertyItem));
           
           //0815 es el código de la nueva propiedad, puedes usar cualquiera 
            //siempre y cuando la imagen no tenga otra propiedad con ese código
            PropertyItems.Id = 0815;
            PropertyItems.Type = 2;
            PropertyItems.Len = bDescription.Length;
            PropertyItems.Value = bDescription;
            Pic.SetPropertyItem(PropertyItems);

            NombreImagen = Guid.NewGuid().ToString() + Ext;
            Pic.Save(NombreImagen, ImageFormat.Jpeg);

            //pbload es el nombre de un picture box que tengo en la aplicación, 
           //al que le voy a asignar la imagen para mostrarla
            pbload.Image = Image.FromFile(NombreImagen);
            pbload.SizeMode = PictureBoxSizeMode.StretchImage;

            //Limpio los recursos usados
            Pic.Dispose();
            Pic = null;
        }


Este otro método, obtiene el texto guardado en la imagen:
        
        /// 
        /// Metodo usado para leer cualquier propiedad de una imagen
        /// 
        /// 
        /// 
        static public string GetDescription(Image img)
        {
            string text = string.Empty;
            System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();

            try
            {
                //Descomentar esta linea si se desea cargar la imagen por medio de path
                //System.Drawing.Image img = new System.Drawing.Bitmap(ImgPath);

                //Se lee la propiedad donde se almaceno la informacion. 0815 es el identificador que le asignamos a la propiedad
                PropertyItem item = img.GetPropertyItem(0815);

                //Se lee el valor y se almacena en una variable para ser devuelto.
                text = encoding.GetString(item.Value);

                //Se liberan los recursos usados.
                img.Dispose();
                GC.SuppressFinalize(img);

                return text;
            }
            catch { return ""; }
        }


Muy pronto agregare el ejemplo de un proyecto detallado junto con un vídeo de explicación: Esperenlo...

Por ahora, les dejo el código de un ejemplo: Descargarlo aqui

Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Curso asterisk con .NET



En estos tiempos donde la comunicación y las telecomunicaciones hacen parte de nuestro diario vivir, es importante que como desarrolladores nos vallamos de frente hacia estos campos.

En ocasiones al ser desarrollador .NET nos enfocamos en solo estas tecnologías y dejamos de lado cualquier cosa que no haga parte del universo microsoft, pero hoy les traigo algo divertido, donde converge el universo pago de microsoft y .NET con lo libre, gratuito y mágico de Linux.

Se trata de unir C# con Asterisk para crear un marcador que desde windows pueda llamar a través de CentOS y Asterisk a cualquier numero.

Los temas de este pequeño pero sustancioso curso son:

  1. Que es asterisk y con que se come?
  2. Montar y configurar servidor con asterisk y CentOS 1
  3. Montar y configurar servidor con asterisk y CentOS 2
  4. Configurar Manager de asterisk
  5. Conectando asterisk con C#

En este curso, aprenderemos como montar y configurar un servidor Asterisk en CentOS 7 para luego conectarnos desde C# y desde aquí poder ejecutar comandos o hacer llamadas en Aterisk.

Semanalmente se subirá una nueva publicación de este super curso! Manténganse atentos y cualquier inquietud, no duden en comentarla!


Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Hora Militar o Formato 24 Horas en SQL SERVER


Es curioso los problemas que nos encontramos a diario al desarrollar, siempre resulta que hay algo nuevo y algo que no sabemos, aprendemos día a día con cada cosa que hacemos, y cada código que escribimos.
El día de hoy les traigo una instrucción que si bien es muy sencilla, puede ahorrarnos varias horas de búsqueda infructuosa en san google. Se trata de convertir una hora en sql server al formato militar o formato de 24 horas.
Para esto tenemos varias formas:


SELECT CONVERT(VARCHAR(8), dateadd(HOUR,12, cast('2017-01-01 10:15:00' as datetime)), 108) 
AS HoraMilitar

Veamos lo que se hace en la instrucción anterior:

Tenemos la fecha y hora: 2017-01-01 10:15:00 la cual convertimos a datetime cast('2017-01-01 10:15:00' as datetime) luego le sumamos 12 horas para ejemplificar el ejercicio "dateadd(HOUR,12," y por ultimo pasamos a varchar para darle formato militar

CONVERT(VARCHAR(8), "Aquí la fecha",108)

Notese que uso el código 108 de conversión, este le indica al motor de base de datos que queremos la hora militar.

Otra forma mas sencilla es convirtiendo a datetime la fecha y hora agregandole AM/PM segun el formato que necesitemos:

SELECT  cast('2017-01-01 10:15:00PM' as datetime) AS HoraMilitar


La diferencia radica en el resultado devuelto, mientras que el primer ejemplo, nos devuelve solo el formato fecha: 22:15:00 el segundo ejemplo nos devuelve el formato completo: 2017-01-01 22:15:00.000

Si tienen una forma mas sencilla o simplemente quieren expresar su opinión, por favor dejen sus comentarios!


Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Goto Inicio



He estado un poco ausente del blog (Bueno en verdad mucho) pero ya es momento de ponernos al día con todas las nuevas tecnologías que han aparecido y que se están convirtiendo poco a poco en el diario vivir de los que estamos inmersos en este mundo del desarrollo y la programación, incluso aquellos que están aprendiendo y quieren llegar mas allá.
Espero que dejen sus comentarios y nos indiquen que les gustaría escribir, recibimos sus códigos y posts para publicarlos!!
Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Desencriptar cadena de texto con C#

Podemos desencriptar cualquier cadena de texto con C# en base a una key de encriptación. El siguiente código espera un parámetro texto del que queremos desencriptar, la key secreta de encriptación, y el CyphMode).

Podemos desencriptar cualquier cadena de texto con C# en base a una key de encriptación. El siguiente código espera un parámetro texto del que queremos desencriptar, la key secreta de encriptación, y el CyphMode).

La función devolverá el valor desencriptado. Nos puede venir bien si queremos desencriptar id's de valores, por ejemplo...


public static string Decrypt(string p_InputString, string p_SecretKey, CipherMode p_CyphMode)

{

 if (String.IsNullOrEmpty(p_InputString)) {

  return String.Empty;

 } else {

  StringBuilder ret = new StringBuilder();

  byte[] InputbyteArray = new byte[Convert.ToInt32(p_InputString.Length) / 2];

  TripleDESCryptoServiceProvider Des = new TripleDESCryptoServiceProvider();

  MD5CryptoServiceProvider hashMD5 = new MD5CryptoServiceProvider();


  try {

   Des.Key = hashMD5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(p_SecretKey));

   Des.Mode = p_CyphMode;

   for (int X = 0; X <;= InputbyteArray.Length - 1; X++) {

    Int32 IJ = (Convert.ToInt32(p_InputString.Substring(X * 2, 2), 16));

    ByteConverter BT = new ByteConverter();

    InputbyteArray[X] = new byte();

    InputbyteArray[X] = Convert.ToByte(BT.ConvertTo(IJ, typeof(byte)));

   }


   MemoryStream ms = new MemoryStream();

   CryptoStream cs = new CryptoStream(ms, Des.CreateDecryptor(), CryptoStreamMode.Write);


   //Flush the data through the crypto stream into the memory stream

   cs.Write(InputbyteArray, 0, InputbyteArray.Length);

   cs.FlushFinalBlock();


   //Get the decrypted data back from the memory stream

   byte[] B = ms.ToArray();

   ms.Close();

   for (int I = 0; I <;= B.GetUpperBound(0); I++) {

    ret.Append(Convert.ToChar(B[I]));

   }

  } catch (Exception ex) {

   //   ME.Publish("SF.Utils.Utils", "DecryptString", ex, ManageException_Enumerators.ErrorLevel.FatalError);

   return String.Empty;

  }


  return ret.ToString();

 }

}


Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Declaración de métodos en C#


Cuando uno plantea una clase en lugar de especificar todo el algoritmo en un único método es dividir todas las responsabilidades de las clase en un conjunto de métodos.
Un método hemos visto que tiene la siguiente sintaxis:
public void [nombre del método]() 
{
    [algoritmo]
}
Veremos que hay varios tipos de métodos:

Métodos con parámetros.

Un método puede tener parámetros:
public void [nombre del método]([parámetros]) 
{
    [algoritmo]
}
Los parámetros los podemos imaginar como variables locales al método, pero su valor se inicializa con datos que llegan cuando lo llamamos.

Problema 1:

Confeccionar una clase que permita ingresar valores enteros por teclado y nos muestre la tabla de multiplicar de dicho valor. Finalizar el programa al ingresar el -1.

Programa:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Tabla
{
    class TablaMultiplicar
    {
        public void CargarValor()
        {
            int valor;
            string linea;
            do
            {
                Console.Write("Ingrese un valor (-1 para finalizar):");
                linea = Console.ReadLine();
                valor = int.Parse(linea);
                if (valor != -1)
                {
                    Calcular(valor);
                }
            } while (valor != -1);
        }

        public void Calcular(int v)
        {
            for(int f=v;f<=v*10;f=f+v) 
            {
                Console.Write(f+"-");
            }
            Console.WriteLine();
        }

        static void Main(string[] args)
        {
            TablaMultiplicar tm = new TablaMultiplicar();
            tm.CargarValor();
        }
    }
}

En esta clase no hemos definido ningún atributo.
El método Calcular recibe un parámetro de tipo entero, luego lo utilizamos dentro del método para mostrar la tabla de multiplicar de dicho valor, para esto inicializamos la variable f con el valor que llega en el parámetro. Luego de cada ejecución del for incrementamos el contador f con el valor de v.
        public void Calcular(int v)
        {
            for(int f=v;f<=v*10;f=f+v) 
            {
                Console.Write(f+"-");
            }
            Console.WriteLine();
        }
Un método puede no tener parámetros como hemos visto en problemas anteriores o puede tener uno o más parámetros (en caso de tener más de un parámetro los mismos se separan por coma)
El método CargarValores no tiene parámetros y tiene por objetivo cargar un valor entero por teclado y llamar al método Calcular para que muestre la tabla de multiplicar del valor que le pasamos por teclado:
        public void CargarValor()
        {
            int valor;
            string linea;
            do
            {
                Console.Write("Ingrese un valor (-1 para finalizar):");
                linea = Console.ReadLine();
                valor = int.Parse(linea);
                if (valor != -1)
                {
                    Calcular(valor);
                }
            } while (valor != -1);
        }
Como vemos al método Calcular lo llamamos por su nombre y entre paréntesis le pasamos el dato a enviar (debe ser un valor o variable entera)
En este problema en la Main solo llamamos al método CargarValor, ya que el método Calcular luego es llamado por el método CargarValor:
        static void Main(string[] args)
        {
            TablaMultiplicar tm = new TablaMultiplicar();
            tm.CargarValor();
        }

Métodos que retornan un dato.

Un método puede retornar un dato:
public [tipo de dato] [nombre del método]([parámetros]) 
{
  [algoritmo]
  return [tipo de dato]
}
Cuando un método retorna un dato en vez de indicar la palabra clave void previo al nombre del método indicamos el tipo de dato que retorna. Luego dentro del algoritmo en el momento que queremos que finalice el mismo y retorne el dato empleamos la palabra clave return con el valor respectivo.

Problema 2:

Confeccionar una clase que permita ingresar tres valores por teclado. Luego mostrar el mayor y el menor.

Programa:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EspacioMayorMenor
{
    class MayorMenor
    {

        public void cargarValores()
        {
            string linea;
            Console.Write("Ingrese primer valor:");
            linea = Console.ReadLine();
            int valor1 = int.Parse(linea);
            Console.Write("Ingrese segundo valor:");
            linea = Console.ReadLine();
            int valor2 = int.Parse(linea);
            Console.Write("Ingrese tercer valor:");
            linea = Console.ReadLine();
            int valor3 = int.Parse(linea);
            int mayor, menor;
            mayor = CalcularMayor(valor1, valor2, valor3);
            menor = CalcularMenor(valor1, valor2, valor3);
            Console.WriteLine("El valor mayor de los tres es:" + mayor);
            Console.WriteLine("El valor menor de los tres es:" + menor);
        }

        public int CalcularMayor(int v1, int v2, int v3)
        {
            int m;
            if (v1 > v2 && v1 > v3)
            {
                m = v1;
            }
            else
            {
                if (v2 > v3)
                {
                    m = v2;
                }
                else
                {
                    m = v3;
                }
            }
            return m;
        }

        public int CalcularMenor(int v1, int v2, int v3)
        {
            int m;
            if (v1 < v2 && v1 < v3)
            {
                m = v1;
            }
            else
            {
                if (v2 < v3)
                {
                    m = v2;
                }
                else
                {
                    m = v3;
                }
            }
            return m;
        }

        static void Main(string[] args)
        {
            MayorMenor mm = new MayorMenor();
            mm.cargarValores();
            Console.ReadKey();
        }
    }
}
Si vemos la sintaxis que calcula el mayor de tres valores enteros es similar al algoritmo visto en conceptos anteriores:

Lo primero que podemos observar que el método retorna un entero y recibe tres parámetros:
        public int CalcularMayor(int v1, int v2, int v3) 

Dentro del método verificamos cual de los tres parámetros almacena un valor mayor, a este valor lo almacenamos en una variable local llamada "m", al valor almacenado en esta variable lo retornamos al final con un return.
La llamada al método calcularMayor lo hacemos desde dentro del método CargarCalores:
        mayor=CalcularMayor(valor1,valor2,valor3);

Debemos asignar a una variable el valor devuelto por el método CalcularMayor. Luego el contenido de la variable mayor lo mostramos:
            Console.WriteLine("El valor mayor de los tres es:"+mayor);
            Console.WriteLine("El valor menor de los tres es:"+menor);

La lógica es similar para el cálculo del menor.
Leer más...

Hacer una peticion Ajax con Jquery



Una vez mas les traemos un post acerca de las bondades de AJAX el cual hemos hablado en posts anteriores...
Hemos hablado de como hacer peticiones AJAX con JQUERY que es algo que nos facilita mucho la vida al momento de actualizar solo una parte de la web, ya que esto lo podemos realizar Asyncronamente.
 jQuery, como framework de JavaScript nos permite realizar esta tarea de forma sencilla, evitando codificar directamente la petición AJAX en JavaScript.

Hoy vamos a realizar una petición a una página para devolver el contenido, que incluiremos en una capa de nuestra página.

Lo primero será montar nuestra página HTML. Con un button y un div.

  
    <div id="mensaje"></div>
     
    <button id="cargar">Cargar</button>


Lo siguiente será inicializar jQuery y empezar a generar el código.
Cargamos la librería jQuery mediante la etiqueta SCRIPT.
 
 <script type="text/javascript" src="jquery.js"></script>

 O llamamos a un CDN que pueden encontrar mas información Aqui.

<script src="http://code.jquery.com/jquery-latest.min.js" type="text/javascript"></script>


Una vez configurado todo...  Lo siguiente será capturar el evento click del botón con Jquery. Para ello, sobre el ID cargar llamamos el evento Click de ese objeto.

  

<script type="text/javascript">
    $(document).ready(function(){
           $("#cargar").click(function(){
               // Petición AJAX
            });     
    });
  </script>


Para hacer la petición AJAX nos apoyaremos en la función .get(url,[data],[callback],[type]). Esta función es muy sencilla y sus parámetros son:
  • url, es la URL que contendrá el fichero que nos devuelva los datos.
  • data, son los datos a enviar a la URl de petición
  • callback, es el método que se ejecutará cuando se realice la petición
  • type, tipo de datos que se devolverán desde el servidor: text, xml, html, json,...
 La peticion AJAX seria:

$.get("http://csharpalextremo.tk//ejemplos/datos.aspx", function(data){
          $("#mensaje").html(data); 
});

En el metodo se puede apreciar varias cosas. La primera que datos.aspx es el fichero que devuelve los datos (no entraremos en detalle de como se compone, pero básicamente devuelve código HTML). La segunda es que la función de callback recibe como parámetro los datos devueltos por el servidor... dentro de esta función lo que estamos haciendo es añadir estos datos a la capa mediante el método .html().

Ahora solo nos queda el explotar las posibilidades del método .get() para dar potencia a nuestra web mediante peticiones AJAX con jQuery.

Pueden DESCARGAR el código de ejemplo desde Aqui. 

Espero que lo disfruten, compartan y comenten. ;)

Visita: http://rubitcorp.co/

"Si se puede imaginar... se puede programar."
Leer más...

Imagen: Editar, Recortar, Redimencionar y Guardar en Carpeta



 En C #, puede ser agotador para hacer ciertas funciones de edición de imagen utilizando GDI +. Este blog tiene algunos métodos de edición divertidas que pueden ser útiles a veces. También he incluido un bonito y pequeño programa en C # para mostrar toda la funcionalidad de los siguientes métodos.
Guardar un Jpeg dentro de una carpeta.

Lo primero a hacer es configurar la firma del método con los parámetros de entrada. Se trata de la ruta de archivo de salvar (cadena), la imagen de guardar (System.Drawing.Bitmap), y un ajuste de calidad (largo).
private void saveJpeg(string path, Bitamp img, long quality)

Lo proximo a hacer es configurar la información del codificador para guardar el archivo. Esto incluye establecer un EncoderParameter para la calidad de la imagen JPEG. El siguiente paso es obtener la información codec de su equipo para jpegs. Hago esto con una función para recorrer las disponibles en el equipo y asegurarse que el codec jpeg está ahí. La línea de bajo se asegura de que el codec JPEG se encuentra en el equipo. Si no simplemente devuelve fuera del método.

La última cosa a hacer es guardar el mapa de bits utilizando el codec y el infomation encoder.

private void saveJpeg(string path, Bitmap img, long quality)
{
   // Encoder parameter for image quality
   EncoderParameter qualityParam = new EncoderParameter(Encoder.Quality, quality);

   // Jpeg image codec
   ImageCodecInfo jpegCodec = this.getEncoderInfo("image/jpeg");

   if(jpegCodec == null)
      return;

   EncoderParameters encoderParams = new EncoderParameters(1);
   encoderParams.Param[0] = qualityParam;

   img.Save(path, jpegCodec, encoderParams);
}

private ImageCodecInfo getEncoderInfo(string mimeType)
{
   // Get image codecs for all image formats
   ImageCodecInfo[] codecs = ImageCodecInfo.GetImageEncoders();

   // Find the correct image codec
   for (int i = 0; i < codecs.Length; i++)
      if (codecs[i].MimeType == mimeType)
         return codecs[i];
   return null;
}

Recorte

El método toma dos objetos - la imagen que desea recortar (System.Drawing.Image) y el rectángulo para recortar (System.Drawing.Rectangle). La siguiente cosa a hacer es crear un mapa de bits (System.Drawing.Bitmap) de la imagen. Lo único que queda por hacer es recortar la imagen. Esto se hace mediante la clonación de la imagen original, pero sólo teniendo un rectángulo de la original.

private static Image cropImage(Image img, Rectangle cropArea)
{
   Bitmap bmpImage = new Bitmap(img);
   Bitmap bmpCrop = bmpImage.Clone(cropArea,
   bmpImage.PixelFormat);
   return (Image)(bmpCrop);
}

Cambiar el tamaño

El siguiente grupo de código es un poco más largo y más complejo. La razón principal que este código es más largo es porque esta función al cambio de tamaño se mantendrá la altura y la anchura proporcional.
Para empezar, vemos que los parámetros de entrada son la imagen para cambiar el tamaño (System.Drawing.Image) y el tamaño (System.Drawing.Size). También en este conjunto de código hay  algunas variables que utilizamos. Los dos primeros son la altura y anchura original que se utiliza más adelante. Y hay 3 otras variables para calcular la información de proporción.

private static Image resizeImage(Image imgToResize, Size size)
{
   int sourceWidth = imgToResize.Width;
   int sourceHeight = imgToResize.Height;

   float nPercent = 0;
   float nPercentW = 0;
   float nPercentH = 0;
}

El siguiente paso es determinar en realidad el tamaño que debe tener la iamgen. El primer paso es el cálculo de los porcentajes del nuevo tamaño en comparación con el original. A continuación tenemos que decidir qué porcentaje es menor porque este es el porcentaje de la imagen original que utilizaremos en altura y en anchura. Y ahora se calcula el número de píxeles de altura y anchura de la imagen de destino.

nPercentW = ((float)size.Width / (float)sourceWidth);
nPercentH = ((float)size.Height / (float)sourceHeight);

if (nPercentH < nPercentW)
   nPercent = nPercentH;
else
   nPercent = nPercentW;

int destWidth = (int)(sourceWidth * nPercent);
int destHeight = (int)(sourceHeight * nPercent);

La última cosa a hacer es crear el mapa de bits (System.Drawing.Bitmap) que vamos a dibujar. La imagen cambia de tamaño en el uso de un objeto Graphics (System.Drawing.Graphics) del objeto. Asimismo, establecer el modo de interpolación, que es el algoritmo usado para cambiar el tamaño de la imagen. Prefiero HighQualityBicubic, que desde mi prueba parece devolver los resultados más altos de calidad. Y sólo para limpiar un poco que disponer del objeto Graphics.

Bitmap b = new Bitmap(destWidth, destHeight);
Graphics g = Graphics.FromImage((Image)b);
g.InterpolationMode = InterpolationMode.HighQualityBicubic;

g.DrawImage(imgToResize, 0, 0, destWidth, destHeight);
g.Dispose();

Y esto nos da el código final.

private static Image resizeImage(Image imgToResize, Size size)
{
   int sourceWidth = imgToResize.Width;
   int sourceHeight = imgToResize.Height;

   float nPercent = 0;
   float nPercentW = 0;
   float nPercentH = 0;

   nPercentW = ((float)size.Width / (float)sourceWidth);
   nPercentH = ((float)size.Height / (float)sourceHeight);

   if (nPercentH < nPercentW)
      nPercent = nPercentH;
   else
      nPercent = nPercentW;

   int destWidth = (int)(sourceWidth * nPercent);
   int destHeight = (int)(sourceHeight * nPercent);

   Bitmap b = new Bitmap(destWidth, destHeight);
   Graphics g = Graphics.FromImage((Image)b);
   g.InterpolationMode = InterpolationMode.HighQualityBicubic;

   g.DrawImage(imgToResize, 0, 0, destWidth, destHeight);
   g.Dispose();

   return (Image)b;
}



Espero que lo disfruten, compartan y comenten. ;)
Visita: http://rubitcorp.co/
"Si se puede imaginar... se puede programar."
Leer más...
Google