Mensajes

Interesante code Hendrix.

Dos cosillas:

Podrias hacer que se añada el http:// a la dirección que tecleas porque si metes www.google.es en vez de http://www.google.es peta el proyecto.

Si de verdad quieres optimizar el code, usa expresiones regulares para buscar los links y correos electronicos. Merece la pena, de verdad.

Te dejo un link sobre ellas por si te interesa.
http://www.microsoft.com/spanish/msdn/comunidad/mtj.net/voices/art101.asp

Salu2

Creo que no se entiende lo que quieres.

No obstante, mirate el code de mi clase Webcam ahi hay varias formas de cambiar de tamaño una imagen capturada.

Salu2

 Si has programado en VB, te acordarás del tipico Inputbox para pedir datos.
Pues bien, teniendo en cuenta que en C# no existe...
Por qué no implementarlo ?

Aqui les dejo el code de la clase Inputbox.
Es estática (no hace falta construir el objeto para usarla) y devuelve datos tipo    string.

Su sintaxis es: Inputbox.Show(Titulo_Ventana,Titulo_Pregunta,Posicion)

Se usa asi:

Código [Seleccionar] Expandir



string n;
n=Inputbox.Show("Inputbox en C#", "Cual es su nombre ? ", FormStartPosition.CenterScreen);
Messagebox.Show(n);



Que lo disfruten !

Código [Seleccionar] Expandir




public static class Inputbox
        {

         // Conserva esta cabecera
        //  Emperorxdevil 2007

            static Form f;
            static Label l;
            static TextBox t; // Elementos necesarios
            static Button b1;
            static Button b2;
            static string Valor;

            /// <summary>
            /// Objeto Estático que muestra un pequeño diálogo para introducir datos
            /// </summary>
            /// <param name="title">Título del diálogo</param>
            /// <param name="prompt">Texto de información</param>
            /// <param name="posicion">Posición de inicio</param>
            /// <returns>Devuelve la escrito en la caja de texto como string</returns>
            public static string Show(string title, string prompt, FormStartPosition posicion)
            {

                f = new Form();
                f.Text = title;
                f.ShowIcon = false;
                f.Icon = null;
                f.KeyPreview=true;
                f.ShowInTaskbar = false;
                f.MaximizeBox = false;
                f.MinimizeBox = false;
                f.Width = 200;
                f.FormBorderStyle = FormBorderStyle.FixedDialog;
                f.Height = 120;
                f.StartPosition = posicion;
                f.KeyPress += new KeyPressEventHandler(f_KeyPress);
               
                l = new Label();
                l.AutoSize = true;
                l.Text = prompt;


                t = new TextBox();
                t.Width = 182;
                t.Top = 40;

                b1 = new Button();
                b1.Text = "Aceptar";
                b1.Click += new EventHandler(b1_Click);


                b2 = new Button();
                b2.Text = "Cancelar";
                b2.Click += new EventHandler(b2_Click);

                f.Controls.Add(l);
                f.Controls.Add(t);
                f.Controls.Add(b1);
                f.Controls.Add(b2);

                l.Top = 10;
                t.Left = 5;
                t.Top = 30;

                b1.Left = 5;
                b1.Top = 60;

                b2.Left = 112;
                b2.Top = 60;

                f.ShowDialog();
                return (Valor);
            }

            static void f_KeyPress(object sender, KeyPressEventArgs e)
            {
                switch(Convert.ToChar(e.KeyChar)) {

                    case ('\r'):
                            Acepta();
                    break;;

                    case (''):
                            Cancela();
                    break;;
                }
            }
            static void b2_Click(object sender, EventArgs e)
            {
                Cancela();
            }
            static void b1_Click(object sender, EventArgs e)
            {
                Acepta();
            }
            private static string Val
            {

                get { return (Valor); }
                set { Valor = value; }
            }
            private static void Acepta() {
                Val = t.Text;
                f.Dispose();
            }
            private static void Cancela() {
                Val=null;
                f.Dispose();
            }


        }


Salu2

Hola a todos.

Aqui les dejo un clase propia para capturar imagenes con la webcam en C#

Esta clase, lista las cam's enchufafas al pc, captura fotos, permite redimensionar la imagen capturada antes de guardarla y elegir el formato de la imagen (jpg,bmp,etc)

Espero que les sirva.

Para usarla, declaren un nuevo objeto webcam.

En el constructor le dicen que frames /s capturara, un picturebox para mostrar la captura y un listbox ( en el que saldran las cam's detectadas).

Usen los metodos Listar, Capturar, StopCaptura y GuardarImagen


Espero que les sirva y les animo a mejorarla.

Código [Seleccionar] Expandir



FrameWork 2.0

Namespaces adicionales para usar esta clase

using System.Drawing.Imaging; // Para trabajar con imágenes
using System.Drawing.Drawing2D; // Para trabajar con Imágenes
using System.Runtime.InteropServices; // Para usar API



Código [Seleccionar] Expandir



  public class WebCam  {
   
     // Conserva esta cabecera
     // Empeorxdevil 2007
   
           class SaveImage {

          // Conserva esta cabecera
          // Emperorxdevil 2007

                      /// <summary>
                      /// Imagen que contiene la clase
                      /// </summary>
                      public  Image Tmp; //  referencia a la imagen del Picturebox Asociado
                      Form Ref; // referencia que necesitare a este formulario
               
                        Form Opciones;
                        GroupBox Gr;
                        RadioButton R1;
                        RadioButton R2;
                        RadioButton R3;
                        TextBox Porciento;
                        TextBox Larg;        // Objetos necesarios para formar el diálogo
                        TextBox Anch;
                        Label L1;
                        Label L2;
                        Button Acepta;
                        Button Cancelar;
                   
                        SaveFileDialog Sv;
                        DialogResult rs;


                /// <summary>
                /// Constructor de clase SaveImage
                /// </summary>
                /// <param name="imagen">Imagen que se va a guardar</param>
                /// <param name="Interfaz"> Si se mostrará Interfaz</param>
                public SaveImage(Image imagen, bool Interfaz) {

                        Tmp=imagen; // Asigno la imagen...             
                         Opciones= new Form();
                         Ref=Opciones;
                         Opciones.Width=333;     // Configuracion
                         Opciones.Height=198;
                         Opciones.Text="Parámetros de Imagen";
                         Opciones.ControlBox=false;
                         Opciones.ShowInTaskbar=false;
                         Opciones.FormBorderStyle=FormBorderStyle.FixedDialog;

                             Gr= new GroupBox();
                             Gr.Width=288;
                             Gr.Height=105;
                             Gr.Text="Configuración";
                             Gr.Location= new Point(18,15);   
                            Porciento= new TextBox();   
                            Porciento.Enabled=false;                   // Configuracion
                            Porciento.Text="";   
                            Porciento.Width=37;
                            Porciento.Height=20;
                            Porciento.MaxLength=3;
                            Porciento.TextAlign=HorizontalAlignment.Center;
                            Porciento.Location= new Point(147,47);
                                R1= new RadioButton();
                                R1.Text="Guardar con Dimensiones Actuales";
                                R1.Width=191;
                                R1.Height=17;
                                Gr.Controls.Add(R1);
                                R1.Location= new Point(18,25);                                   
                                R2 = new RadioButton();
                                R2.CheckedChanged += new EventHandler(R2_CheckedChanged);
                                R2.Text="Reducir tamaño al";
                                R2.Width = 115;             // Configuracion
                                R2.Height = 17;
                                R2.Location= new Point(18,48);
                                Gr.Controls.Add(R2);
                                Gr.Controls.Add(Porciento);
                                L1 = new Label();
                                L1.Text="%";
                                L1.AutoSize=true;
                                L1.Location= new Point(195,50);
                                Gr.Controls.Add(L1);
                                R3 = new RadioButton();
                                R3.CheckedChanged += new EventHandler(R3_CheckedChanged);
                                R3.Text="Cambiar tamaño a"; // Configuracion
                                R3.Width=113;
                                R3.Height=17;
                                R3.Location= new Point(18,71);
                                Gr.Controls.Add(R3);
                                L2 = new Label();
                                L2.Text="X";
                                L2.AutoSize=true;
                                L2.Location=new Point(195,75);
                                Gr.Controls.Add(L2);
                    Larg= new TextBox();
                    Larg.Enabled=false;
                    Larg.Width=37;
                    Larg.Height=20;
                    Larg.MaxLength=4;
                    Larg.TextAlign=HorizontalAlignment.Center;
                    Larg.Location= new Point(147,71);
                    Gr.Controls.Add(Larg);

                    Anch= new TextBox();
                    Anch.Enabled=false;
                    Anch.Width=37;
                    Anch.Height=20;
                    Anch.MaxLength=4;
                    Anch.TextAlign=HorizontalAlignment.Center; // Configuracion
                    Anch.Location= new Point(218,70);
                    Gr.Controls.Add(Anch);                   

                           Acepta= new Button();
                           Acepta.Text="Aceptar";
                           Acepta.Width=59;
                           Acepta.Height=26;
                           Acepta.Location= new Point(247,133);
                           Acepta.Click += new EventHandler(Acepta_Click);

                           Cancelar= new Button();
                           Cancelar.Text="Cancelar";
                           Cancelar.Width= 59;
                           Cancelar.Height=26;
                           Cancelar.Location= new Point(18,133);
                           Cancelar.Click += new EventHandler(Cancelar_Click);
                                Opciones.Controls.Add(Gr);
                                Opciones.Controls.Add(Acepta);
                                Opciones.Controls.Add(Cancelar);
                                Opciones.StartPosition=FormStartPosition.CenterScreen;
                                Opciones.ShowDialog();
                     
                }

               
                /// <summary>
                /// Constructor de la clase SaveImage sin Interfaz
                /// </summary>
                /// <param name="imagen">Imagen a Guardar</param>
                public SaveImage(Image imagen) {
                    Tmp = imagen; // Asigno la imagen... 
                }

                void R3_CheckedChanged(object sender, EventArgs e)
               {
                   if (this.R3.Checked) { this.Anch.Enabled=true; this.Larg.Enabled=true;}
                   else {this.Anch.Enabled=false; this.Larg.Enabled=false; }
               }
                void R2_CheckedChanged(object sender, EventArgs e)
               {
                   if (this.R2.Checked) { this.Porciento.Enabled=true;}
                   else { this.Porciento.Enabled=false; }
               }
                void Acepta_Click(object sender, EventArgs e)
               {
                     try {
                            if (R1.Checked|| R2.Checked||R3.Checked) {               
                                   
                             if (R2.Checked) {Tmp=Resize(Tmp,Convert.ToInt32(Porciento.Text));}
                             
                             if (R3.Checked) {Tmp=Resize(Tmp,Convert.ToInt32(Larg.Text),Convert.ToInt32(Anch.Text)); }     
   
                                   Sv= new SaveFileDialog(); // Creo un diálogo para salvar la imagen
                                   Sv.Title = "Guardar imagen como..."; // Lo configuro
                                   Sv.Filter = "Archivo JPG|*.jpg|Archivo PNG|*.png|Archivo GIF|*.gif|Mapa de Bits|*.bmp";
                                   rs = Sv.ShowDialog(); // Lo muestro modal


                                   if (rs == DialogResult.OK) {
                                   
                                       int x = Sv.FilterIndex; // Ontengo la extensión seleccionada 

                                       switch (x)
                                       {
                                           // Salvo la imagen en el formato deseado
                                           case 1:
                                               Tmp.Save(Sv.FileName, ImageFormat.Jpeg);
                                               break;
                                           case 2:
                                               Tmp.Save(Sv.FileName, ImageFormat.Png);
                                               break;
                                           case 3:
                                               Tmp.Save(Sv.FileName, ImageFormat.Gif);
                                               break;
                                           case 4:
                                               Tmp.Save(Sv.FileName, ImageFormat.Bmp);
                                               break;
                                       }
                                            Ref.Dispose(); // Cierro el formulario       
                                   }
                                }
                                else { MessageBox.Show("Al menos debe selecionar una opción","xdevilWebCapture", MessageBoxButtons.OK, MessageBoxIcon.Warning); }

                                }
   
                                catch {
                                    MessageBox.Show("Introduzca valores válidos", "xdevilWebCapture", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                                }     

               }                 
                void Cancelar_Click(object sender, EventArgs e)
                {
                     Ref.Dispose(); // Cierro el formulario
                }



                /// <summary>
                /// Escala la imagen capturada al % especificado
                /// </summary>
                /// <param name="foto"> Imagen que se quiere escalar </param>
                /// <param name="TantoPorCiento"> Porcentaje de reducción</param>
                /// <returns>Imagen escalada</returns>
                public Image Resize(Image foto,int TantoPorCiento) {

                        float Tporciento=((float)TantoPorCiento/100); // Obtengo el coeficiente de dimension                   
                        int ImgOrAncho=foto.Width;
                        int ImgOrAlto=foto.Height; // Obtengo las dimensiones originales de la foto

                        int OrigX=0;
                        int OrigY=0;
                        int ResX=0;  // Variables referencia para saber donde empiezo a contar px
                        int ResY=0;

                        int ResAncho=(int)(ImgOrAncho*Tporciento);
                        int ResAlto = (int)(ImgOrAlto * Tporciento); // Obtengo las dimensiones al % especificado   

                      Bitmap RszIm= new Bitmap(ResAncho,ResAlto,PixelFormat.Format24bppRgb); // Creo una imagen con esas dimensiones y bpp
                      RszIm.SetResolution(foto.HorizontalResolution,foto.VerticalResolution); // Le doy la misma res. que la original
                       
                      Graphics Gfoto= Graphics.FromImage(RszIm); // Creo una intancia de Graphics para manejar la imagen nueva
                      Gfoto.InterpolationMode= InterpolationMode.HighQualityBicubic; // Especifico la calidad del algoritmo de sampleo
                      // De la foto original, obtengo la redimensionada (mediante un rectángulo)
                      Gfoto.DrawImage(foto,new Rectangle(ResX,ResY,ResAncho,ResAlto),new Rectangle(OrigX,OrigY,ImgOrAncho,ImgOrAlto),GraphicsUnit.Pixel);   
                      Gfoto.Dispose(); // Ya no me hace falta esto, asi que lo descargo

                        return(RszIm); // Devuelvo la imagen redimensionada
                }
                /// <summary>
                /// Redimensiona la imagen en pixeles
                /// </summary>
                /// <param name="foto"> Imagen a redimensionar</param>
                /// <param name="ancho">Ancho de la imagen</param>
                /// <param name="alto">Alto de la imagen</param>
                /// <returns>Imagen redimensionada</returns>
                public Image Resize(Image foto, int ancho, int alto) {

                            int ImgORAncho = foto.Width;
                            int ImgOrAlto =  foto.Height; // Obtengo las dimensiones de la foto

                            int OrigX = 0;
                            int OrigY = 0;
                            int ResX = 0;  // Varables referencia para saber donde contar px
                            int ResY = 0;

                            float Porciento = 0;
                            float PorcientoAncho = 0; // Porcentajes de sampleo
                            float PorcientoAlto = 0;

                    PorcientoAncho = ((float)ancho / (float)ImgORAncho);
                    PorcientoAlto  = ((float)alto / (float)ImgOrAlto); //Calculo el % que puedo resamplear
   
                        if (PorcientoAlto  < PorcientoAncho){
                                    Porciento  = PorcientoAlto; }
                            else { // Para resamplear bien                 
                                    Porciento = PorcientoAncho; }
                         

                    int AnchuraFinal = (int)(ImgORAncho  * Porciento);
                    int AlturaFinal;  // Calculo las nuevas dimensiones               
       
                            if (ancho >alto) {
                                        AlturaFinal = (int)(ImgOrAlto  * Porciento); }
                               else {
                                    AlturaFinal =AnchuraFinal;} // Para proporcionar la imagen

                    Bitmap RszIm = new Bitmap(ancho, alto,PixelFormat.Format24bppRgb);
                    RszIm.SetResolution(foto.HorizontalResolution,foto.VerticalResolution);

                    Graphics Gfoto = Graphics.FromImage(RszIm);
                    Gfoto.InterpolationMode =InterpolationMode.HighQualityBicubic;
                    Gfoto.DrawImage(foto,new Rectangle(ResX, ResY, AnchuraFinal, AlturaFinal),new Rectangle(OrigX, OrigY, ImgORAncho , ImgOrAlto),GraphicsUnit.Pixel);
                    Gfoto.Dispose();
                    return (RszIm);

                }

            } /// Clase que guarda las imágenes

             #region Funciones API

          [DllImport("user32.dll", EntryPoint = "SendMessage")]
          public static extern int SendMessage(int hWnd, uint Msg, int wParam, int lParam);

          [DllImport("avicap32.dll", EntryPoint = "capCreateCaptureWindowA")]
          public static extern int capCreateCaptureWindowA(string lpszWindowName, int dwStyle, int X, int Y, int nWidth, int nHeight, int hwndParent, int nID);

          [DllImport("user32.dll", EntryPoint = "EmptyClipboard")]
          public static extern int EmptyClipboard();
         
          [DllImport ("avicap32.dll",EntryPoint="capGetDriverDescriptionA")]
          public static extern bool capGetDriverDescriptionA(int wdriver,string lpszName,int cbName,string lpszVer,int cbVer);

         
             #endregion

             #region Constantes API

          const int WM_USER = 1024;
          const int WM_CAP_CONNECT = 1034;
          const int WM_CAP_DISCONNECT = 1035;
          const int WM_CAP_GET_FRAME = 1084;  // Constantes necesarias
          const int WM_CAP_COPY = 1054;
          const int WM_CAP_START = WM_USER;
          const int WM_CAP_SET_PREVIEW = WM_CAP_START + 50;
          const int WM_CAP_SET_PREVIEWRATE = WM_USER + 52;
         
       #endregion
     
             private int Frecuencia=0; // Frecuencia de captura de imagen   
             private  int CamHandle=0; // Handle del dispositivo
                     

             Timer reloj; // Timer
             ComboBox Cbx; // Para referencia al Combobox
             PictureBox Pbx; // Para referencia al Picturebox
                       
         
        /// <summary>
        /// Crea una instancia de la clase WebCam de Emperorxdevil
        /// </summary>
        /// <param name="frecuencia">Intervalo de tiempo en el que se capturarán las imágenes</param>
        /// <param name="pct">PictureBox en el cual se mostrará lo capturado por la webcam</param>
        /// <param name="cb"> Listbox en el que se mostrarán las Cams detectadas</param>
        public WebCam(int frecuencia,PictureBox pct, ComboBox cb) {
             
            Frecuencia=frecuencia;
            Pbx=pct;              // Inicio las variables necesarias
            reloj= new Timer(); // Creo el timer
            reloj.Tick += new EventHandler(reloj_Tick); // Le asigno el controlador   
            reloj.Interval=Frecuencia; // Asigno la velocidad de captura
            Cbx= cb; //Configuro la referencia
           
           }

        private void reloj_Tick(object sender, EventArgs e)
        {

            SendMessage(CamHandle, WM_CAP_GET_FRAME,0,0); // Capturo la imagen
            SendMessage(CamHandle, WM_CAP_COPY, 0, 0); // La copio al portapeles
            Pbx.Image=Clipboard.GetImage(); // La mando al Picturebox
            EmptyClipboard(); // Vacío el portapapeles
           
        }
        /// <summary>
        /// Listará las cámaras web encontradas en el Combobox asociado
        /// </summary>
        public void Listar() {
                   
              bool valor;
              string nombre;   
              string version;
              int x=0;

                do {
                    nombre="Dispositivo"+x.ToString();
                    valor=capGetDriverDescriptionA(x,nombre,100,"v1",100);
                     if (valor) Cbx.Items.Add(nombre);
                     x=x+1;
                } while (!valor==false);                       
                   
        }
        /// <summary>
        /// La WebCam se Encenderá y mostrará lo capturado en el PictureBox referenciado
        /// </summary>
        /// <param name="Dispositivo">Nº de dispositivo del Combobox</param>         
        public void Capturar(int Dispositivo) {

                        try {
                             
                              StopCaptura(); // Antes de nada "reseteo" el dispositivo 
                              CamHandle= capCreateCaptureWindowA("XdevilCapture"+Dispositivo.ToString(),0,0,0,0,0,Pbx.Handle.ToInt32(),Dispositivo); // Obtengo el Handle de la cam
                              SendMessage(CamHandle, WM_CAP_CONNECT, 0, 0); // Enciendo la cam
                              SendMessage(CamHandle,WM_CAP_SET_PREVIEWRATE,30,0); // Establezco los frames de captura /seg
                              SendMessage(CamHandle, WM_CAP_SET_PREVIEW,0,0); // Empiezo a capturar
                              reloj.Start(); // Inicio la captura     
                        }

                        catch (Exception e) {
                              MessageBox.Show("No se puede Iniciar la WebCam","Error");             
                        }

              }
        /// <summary>
        /// Detiene la captura de imágenes y apaga la WebCam
        /// </summary>
        public void StopCaptura() {


                       try {
                           reloj.Stop(); // Paro el reloj que captura
                           SendMessage(CamHandle, WM_CAP_DISCONNECT, 0, 0); // Apago la cam
                           EmptyClipboard(); // Vacío el portapapeles
                         }

                        catch (Exception e) { } // No hago nada.. pa k ?

              }
        /// <summary>
        /// Muestra diferentes parametros configurables de la imagen que se va a guardar
        /// </summary>
        public void GuardarImagen() {
                 
                SaveImage s= new SaveImage(Pbx.Image,true); // Creo la clase que guarda las fotos
              }   
       
     
    }



Salu2