Como estudiante de Ingeniería en Sistema Computacionales he encontrado una gran pasión por el tema de Algoritmos Evolutivos, hace poco tiempo leí una serie de libros relacionados con el tema y tomé nota de esas lecturas. Aquí les presento esas notas con referencias completas de los libros consultados, en esta ocasión el post es enfocado al paradigma más conocido dentro de los algoritmos evolutivos: Algoritmo Genéticos.

Introducción

Durante los últimos treinta años ha crecido el interés en sistemas basados en los principios de la evolución y herencia naturales, para resolver cierto tipo de problemas, dichos sistemas mantienen una población de soluciones potenciales, tienen algún proceso de selección basado en la aptitud de los individuos y algunos operadores “genéticos”. Las Estrategias Evolutivas son un tipo de esos sistemas i.e., algoritmos que imitan los principios de evolución natural para problemas de optimización por parámetros. La programación evolutiva de Fogel es una técnica por búsqueda a través de un espacio de pequeñas máquinas de estados finitos. Otro tipo de sistemas basados en la evolución natural son los Algoritmos Genéticos de Hollman. En 1990 Koza propusó otro tipo de sistemas, la Programación Genética, para buscar el programa computacional más apto para resolver un problema en particular. [1, pp. 1].

Orígenes

Los algoritmos genéticos son una técnica de búsqueda y optimización basada en los principios de la genética y la selección natural.Un algoritmo genético mantiene una población de varios individuos que evolucionan a un estado, bajo reglas especificadas, para maximizar la “aptitud” (i.e., maximizar el costo de una función). [2]Los algoritmos genéticos únicamente maximizan, pero la minimización puede realizarse fácilmente utilizando el recíproco de la función maximizante (debe cuidarse, por supuesto, que el recíproco de la función no genere una división por cero) ,i.e. si el problema es minimizar una función f esto es equivalente a maximizar una función g donde g = -f:

Una definición bastante completa de un algoritmo genético es la propuesta por J. Koza [3, pp. 819]:

Es un algoritmo matemático altamente paralelo que transforma un conjunto de objetos matemáticos individuales con respecto al tiempo usando operaciones modeladas de acuerdo al principio Darwiniano de reproducción y supervivencia del más apto, y tras haberse presentado de forma natural una serie de operaciones genéticas de entre las que destaca la recombinación sexual. Cada uno de estos objetos matemáticos suele ser una cadena de caractéres (letras o números) de longitud fija que se ajusta al modelo de las cadenas de cromosomas, y se les asocia con una cierta funci\’on matem\’atica que refleja su aptitud.

 

Estos algoritmos son muy probablemente los tipo de algoritmos evolutivos más ampliamente conocidos al día de hoy, recibiendo notable atención en todo el mundo. Probablemente el primer predecesor de éstos algoritmos surgió del trabajo de Fraser, un biólogo quien quería simular el proceso de evolución, con especial énfasis en la interacción de la epistasis(Un fenómeno, en el cual, las características de un gen son modificados por uno ó más genes) con selección. Trabajos similares a los de Fraser fueron resumidos por Goldberg [4, pp. 89-103].

Sin embargo, los algoritmos genéticos en su forma usual fueron desarrollados por Holland, científico computólogo y psicólogo de la Universidad de Michigan. En 1975 él resumió su trabajo en “adaptive and reproductive plans” un libro que sirve como el punto inicial de las primeras aplicaciones e implementaciones de algoritmos genéticos [4]. Mientras los biólogos intentaban simular evolución usando algoritmos genéticos, Holland estudiaba como éste tipo de algoritmos podrían ser combinados con problemas que ocurren en campos de aplicación práctica [5, pp. 106-107].

Los AG’s toman prestado cierto vocabulario de la genética. Se habla de individuos (o genotipos) en una población, algunas veces esos individuos son llamados cadenas o cromosomas, esto podría ser un poco confuso, para aclararlo veamos la siguiente explicación:

Cada célula de todo organismo de una especie dada acarrea un cierto número de cromosomas ( el hombre, por ejemplo, tiene 46 de ellos), sin embargo, aquí se hablará de individuos con un solo cromosoma, i.e. cromosomas haploides. Los cromosomas a su vez están formados de genes (también conocidos como características, caracteres ó decodificadores) organizados en sucesión lineal; cada gen controla la herencia de una o más características. Los genes de ciertas características esta colocados en ciertos lugares del cromosoma, a esta posición se le conoce como loci(posición dentro de la cadena).

Cada característica de los individuos (como el color de su cabello) puede manifestarse de diferentes maneras, se dice entonces que el gen puede estar en varios estados, llamados alelos.

Cada genotipo(un único cromosoma) representaría una posible solución a un problema, un proceso de evolución se ejecuta sobre una población de cromosomas correspondientes a una búsqueda a través de un espacio de soluciones potenciales. Por lo que una búsqueda requiere balancear dos objetivos (aparentemente conflictivos): explotar las mejores soluciones y explorar el espacio de búsqueda [6 pp. 61-73].

El Algoritmo Genético Canónico

El AG comienza, como cualquier otra técnica de optimización, definiendo las variables de optimización, la función mediante la cual se evaluarán las variables y el costo. Éste termina también como otros algoritmos de optimización, haciendo pruebas de convergencia. En la fase intermedia, sin embargo, el algoritmo es un poco diferente. En la figura 1 se muestra una ruta a través de los componentes de un algoritmo genético “canónico” o estándar [2, pp. 52].

Estructura general de un algoritmo genético

El siguiente paso es generar una población inicial compuesta por cadenas ó cromosomas de longitud L, generalmente ésta se inicia aleatoriamente, diversas formas de inicializar una población pueden encontrarse en [3]. Cada miembro de dicha población es representado de acuerdo al problema, pero podemos encontrar tres tipos de representaciones comunes [7]:

• Representación Binaria: Cada gen es un valor de 0 ó 1.
• Representación Entera: Cada gen es un valor entero.
• Representación Real: Cada gen es un valor real.

Operadores Genéticos

Después de crear la población inicial, cada cromosoma es evaluado y se le asigna un valor de aptitud. Es importante distinguir entre lo que se conoce como una función de evaluación y una función aptitud; la función de evaluación, o función objetivo, proporciona una medida del desempeño con respecto a un conjunto de parámetros. La función aptitud transforma esa medición en asignación de oportunidades de reproducción para el individuo. La evaluación de una cadena es independiente de la evaluación de cualquier otra cadena. La aptitud, sin embargo, es siempre definida con respecto a otros miembros de la población actual.

Selección

La selección es la etapa del algoritmo genético en la cual individuos o cromosomas se eligen de una población para su posterior reproducción (recombinación y/o cruce).

Fundamentalmente, pueden considerarse 3 esquemas de selección, aunque existe múltiples esquemas distintos a estos, así como innumerables combinaciones de aspectos de estos tres mecanismos fundamentales. A continuación se describe cada uno de ellos:

Ruleta o Seleccion proporcional: Con este método la probabilidad que tiene un cromosoma de reproducirse es proporcional a su valor de función de evaluación, es decir, a su adaptación. Una vez calculadas estas probabilidades, la selección de los individuos para reproducirse es aleatoria según estos valores. El algoritmo propuesto por Goldberg(1989) es el siguiente:

• Construcción de la ruleta: Calcular el valor de aptitud eval(u) para cada cromosoma de la población actual (i=1, … , tamp), donde tamp corresponde al tamaño de la población.
• Calcular el valor total de la aptitud de la población

• Calcular la probabilidad de selección de cada cromosoma 

• La ruleta gira tamp veces, cada vez seleccionamos un cromosoma para una nueva población de la siguiente forma:
• Generar un número aleatorio flotante r del rango [0 ... 1].
• Si   entonces seleccionar el primer cromosoma , en otro caso seleccionar el i-ésimo cromosoma  (2 ≤ i ≤ tamp) tal que

Obviamente con este algoritmo, algunos cromosomas serán elegidos en distintas ocasiones.

Selección por ranking: Desarrollado por Whitley en 1989, el método consiste en calcular las probabilidades de reproducción atendiendo a la ordenación de la población por el valor de aptitud en vez de simplemente el valor de la función, la aptitud esta definida por:, donde   es la evaluación asociada con el cromosoma i , y   es la evaluación promedio de todos los cromosomas en la población [8]. Una vez realizada esta evaluación, se simula un proceso de selección natural, los individuos son acomodados de acuerdo a la función de aptitud, en esta etapa los mejores individuos son elegidos de la población actual y el resto son eliminados. Esta selección natural ocurre cada generación o iteración del algoritmo. La decisión del número de cromosomas elegidos es algo arbitrario, sin embargo, dejando que solo unos pocos cromosomas sobrevivan para la siguiente generación limita los genes disponibles para producir descendientes, almacenando demasiados cromosomas permite que los cromosomas con baja aptitud reproduzcan sus características en la siguiente generación.

Selección por torneo: Un esquema ideal de selección debería ser simple de codificar, y eficiente para arquitecturas paralelas y no paralelas, más aún, un esquema de selección debería ser capaz de ajustar su influencia de selección acorde a su dominio. El uso de selección por torneo ha ido en incremento debido a que satisface los criterios anteriores[9]. La idea es simple, se elige un número de individuos de una población(normalmente 2, torneo binario), se selecciona el mejor individuo de este grupo para un nuevo procesamiento genético, la selección se realiza tantas veces como se desee (por lo general hasta que a partir de ellos, sea posible realizar el proceso de apareamiento). El método puede aplicarse con reemplazo o sin reemplazo, en el primer caso los individuos seleccionados del actual torneo son candidatos para participar en otro torneos, por otro lado en un torneo sin reemplazo los individuos son seleccionados una sola vez.

Una comparación de complejidad entre estos tres esquemas de selección puede verse en [10].

Operador Mutación

El operador de mutación fue introducido por Holland como un operador que ocasionalmente cambia bits individuales de cromosomas invirtiéndolos, la probabilidad de mutación   por bit es muy pequeña en un AG. Algunos valores comúnes son: y . En últimos estudios, algunos investigadores formularon algunas reglas heurísticas indicando que el rendimiento es cada vez mayor tanto para poblaciones grandes (tamp > 200) combinadas con una probabilidad de mutación grande como también para poblaciones de pequeño tamaño combinadas con una probabilidad de mutación pequeña .

Valores pequeños de mutaciones, como Holland indica, garantiza que un individuo producido por mutación no difiera demasiado genéticamente de su antecesor. Esta declaración es cierta para el espacio de genotipos, pero como Bäck señala, solo es compatible con una codificación estándar(binaria) no para una representación con números reales [11].

El gen a mutar es seleccionado aleatoriamente del número total de genes (tamp * L) de la población actual.

Recombinación o Cruce

La recombinación es considerado como el operador más importante de los algoritmos genéticos. La idea es que segmentos útiles de diferentes padres podrían ser combinadas con el fin de dar a un nuevo individuo los beneficios de combinaciones de bits de ambos padres. De esta forma, más y más segmentos de aptitud alta se esperan que emergan, finalmente llegando a una total solución [5, pp. 97-106].

La recombinación es claramente un operador sexual(necesita dos cromosomas o individuos para llevarse a cabo) que con una probabilidad selecciona dos individuos padres de la población, los recombina para formar dos nuevos individuos y descarta uno de los resultantes.

Valores comunes de son los propuestos por De Jong(1975) con   y J.J Grefenstette(1985) con una .

El operador de cruce permite realizar una exploración de toda la información almacenada hasta el momento en la población y combinarla para crear mejores individuos.

El tradicional método de cruce propuesto por Holland se conoce como one-point crossover:

Se elige una posición de cruce 1, … , L-1 dentro de la cadena de bits al azar y se intercambian los bits a la derecha de esa posición entre ambos individuos. Sin embargo, éste método parece ser claramente inferior a los otros métodos con respecto al desempeño de los resultados.

Cruce de n puntos: Es una generalización del método anterior. Se seleccionan varias posiciones (n) en las cadenas de los progenitores y se intercambian los genes a ambos lados de estas posiciones.

Cruce Uniforme: Es radicalmente diferente a la técnica de un punto, cada gen de los descendientes es creado copiando el correspondiente gen de uno o del otro padre, elegido de acuerdo a una máscara de cruce generada aleatoriamente. Cuando existe un 1 en la máscara de cruce, el gen es copiado del primer padre, y cuando la posición de la mascara contiene un 0, el gen es copiado del segundo padre. El proceso es repetido intercambiando a los padres para generar el segundo descendiente. Para cada par de padres se genera una máscara nueva, los descendientes por lo tanto, contienen una mezcla de genes de cada padre. El número de puntos de cruce efectivos no es fijo, pero la media podría ser (donde L) es la longitud de los cromosomas).

Cruce heurístico: Éste operador propuesto por Wright \cite {Wright}, es único debido a las siguientes razones:

1. Utiliza valores de la función objetivo para determinar la dirección de la búsqueda
2. Produce únicamente un descendiente
3. Podría no producir ningún descendiente

El operador genera un descendiente de dos padres  y  de acuerdo siguiente regla:

Donde  r es un número aleatorio entre 0 y 1, y el padre    no es peor que , es decir,   para problemas de minimización.

Es posible que el operador genere un descendiente no viable. En tal caso otro valor aleatorio es generado y otro descendiente creado, si después de w intentos una nueva solución viable no es encontrada, el operador no hace más intentos y no produce ningún descendiente.

Después de que el proceso de selección, mutación y recombinación está completo, la siguiente población puede ser evaluada; este proceso formará una generación o ciclo en la ejecución de un algoritmo genético.

En cuanto el criterio de parada, generalmente viene determinado por criterios a priori sencillos, como un número máximo de generaciones o un tiempo máximo de resolución, o más eficientemente por estrategias relacionadas con indicadores del estado de evolución de la población, como por la pérdida de diversidad dentro de la población o por no haber mejora en un cierto número de iteraciones, siendo por lo general una condición mixta lo más utilizado, es decir, limitar el tiempo de ejecución a un número de iteraciones y tener en cuenta algún indicador del estado de la población para considerar la convergencia antes de alcanzar tal limitación.

Hasta Aqui llega esta breve introducción, esperando a que los aliente a meterse más en este campo, para esto les recomiendo un gran sitio del Dr. Carlos Coello actual investigador del CINVESTAV en el IPN y que resolvió algunas de mis dudas.

De antemano me disculpo si por ahí se me fué alguna expresión mal, es dificil trabajar sin LaTeX directamente. Saludos!!

Bibliografía:

[1] Zbigniew Michalewicz. Genetic algorithms + data structures = evolution programs (3rd ed.).  Springer-Verlag, London, UK, 1996.
[2] Randy L. Haupt and Sue Ellen Haupt. Practical Genetic Algorithms. Wiley-Interscience, 2004.
[3] John R. Koza. Genetic Programming: On the Programming of Computers by Means of Natural Selection (Complex Adaptive Systems). The MIT Press, 1 edition, December 1992.
[4] David E. Goldberg. Genetic Algorithms in Search, Optimization, and Machine Learning. Addison-Wesley Professional, 1 edition, January 1989.
[5] John H. Holland. Adaptation in natural and artificial systems. MIT Press, Cambridge, MA, USA, 1992.
[6] L.B. Booker. Improving Search in Genetic Algorithms. Morgan Kaufmann Publishers, 1987.
[7] Rafael Caballero Fern ́ndez. Algoritmos gen ́ticos para la resoluci ́n de problemas de programación por metas entera. aplicación a la economía de la educación.
[8] Darrell Whitley. A genetic algorithm tutorial. Statistics and Computing, 4(2), June 1994.
[9] Brad L. Miller, Brad L. Miller, David E. Goldberg, and David E. Goldberg. Genetic algorithms, tournament selection, and the effects of noise. Complex Systems, 9, 1995.                                                                                                                                                                                                                [10]Thomas Bäck. Evolutionary Algorithms in Theory and Practice: Evolution Strategies, Evolutionary Programming, Genetic Algorithms. Oxford University Press, 1996.                                                                                                                                                                                                                               [11]Alden H. Wright. Genetic algorithms for real parameter optimization. In Foundations of genetic algorithms. Morgan Kaufmann, San Mateo, CA, 1991.

CKEditor es un editor de texto para ser utilizado dentro de las páginas web. Es un editor WYSIWYG es el acrónimo de What You See Is What You Get (en inglés, “lo que ves es lo que obtienes”) . Reúne las características de edición web común que se encuentran en aplicaciones de edición de escritorio como Microsoft Word y OpenOffice.

Y ahora lo usaremos dentro de Ruby on Rails así como su configuración y aparecía básica.

Empecemos !!!!

1. Para usar CKEditor necesitamos instalarlo para lo cual descargaremos la gema desde http://rubygems.org/gems/ckeditor
2. Ahora instalemos la gema desde la terminal escribimos gem install ckeditor-3.5.2.gem
3. Creemos un proyecto nuevo de rails.
4. Ahora basta con modificar el Gemfile agregando la lineagem ‘ckeditor’ o gem ‘ckeditor’, :git => ‘git://github.com/galetahub/rails-ckeditor.git’, :branch => ‘rails3′
   
5. Para que nuestra aplicación reconosca esta linea usemos el bundle.
6. El siguiente paso es descargar los archivos de base CKEditor y generar el archivo de configuración “config/initializers/ckeditor.rb”
7. Generar los modelos CKEditor para subir ficheros.
8. Ahora hacemos la migración.
9. Listo ahora podemos usar el CKEditor en nuestra aplicación para ello basta con incluirlo en la vista: Primero en el archivo de “/app/views/layouts/application.html.erb” se agraga la linea “<%= javascript_include_tag :ckeditor %>” despues basta con poner la siguiente linea en la vista que se usara el CKEditor : “<%= ckeditor_textarea(“object”, “field”, :width => ’100%’, :height => ’200px’) %>” . Si se utilizara en un formulario la linea es la siguiente : ” <%= form.cktext_area :notes, :toolbar=>’Full’, :width=>’400px’, :height=>’200px’ %> <%= form.cktext_area :content, :swf_params=>{:assetable_type=>’User’, :assetable_id=>current_user.id} %>”
10. Nos deve de quedar algo masomenos asi:
11. Para agregar o quitar opciones de la barra de herramientas del CKEditor simplemente se edita el fichero “public/javascripts/ckeditor/config.js”Good Luck!!

En esta ocasión aquí les dejo un tutorial de cómo realizar un pequeño Syntax Highlight en C#, ya que realizarlo completo seria muy complejo, aquí lo básico para iniciar a crear un Syntax Highlight. 

Lo primero que necesitamos es insertar un RichTextBox y poner las siguientes propiedades del RichTextBox como se indican 

AcceptsTab = True 

Para que mientras escribamos se pueda usar la tecla TAB en lugar de que con ella se pase al siguiente componente en el formulario. 

DetectUrls = False 

Voy a desactivar esta opción para que no se mezcle con la forma de resaltar código. 

Font-name = Consolas  

Utilizo esta fuente para que se vea como código y no como texto normal. 

Cada vez que el texto cambie, tenemos que volver a darle formato al texto. Es por esta razón que todo el código necesario lo vamos a programar en el evento Text_Changed del RichTextBox. 

Lo que tenemos que hacer en este evento es ir seleccionando porciones de texto y cambiándole valores como color, fuente, etc. Podemos seleccionar todo el texto usando el comando SelectAll o porciones de texto usando el atributo SelectionStart y SelectionLength que marcan el inicio y longitud del pedazo seleccionado. Una vez que seleccionamos un pedazo de texto, podemos aplicarle formato utilizando una serie de propiedades, pero la que usaremos en este ejemplo es simplemente SelectionColor que nos permitirá cambiarle el color al texto seleccionado. 

Para poder utilizar expresiones regulares en nuestro Sintax Highlight es necesario utilizar el siguiente nameSpace : 

using System.Text.RegularExpressions;

Ponemos el siguiente código dentro del evento Text_Changed del RichTextBox. 

// Esta primer linea es necesari para evitar el parparpadeo que se produce al seleccionar texto en diferentes partes, lo cual se produce demasioadp rapido y solo vemos el parpadeo richTextBox1.Enabled = false; //Desabilitamos el RichTextBox int selStart = richTextBox1.SelectionStart; int selLength = richTextBox1.SelectionLength;

// Nos aseguramos de que todo el texto
// este negro antes de ponerle color
richTextBox1.SelectAll();
richTextBox1.SelectionColor = Color.Black;

Regex reg;
MatchCollection partes;

// validamos palabras reservadas
reg = new Regex(“(drop|select|table|insert into|from|update|values|where|alter|create|if|exists|foreign key|primary key|constraint|default|engine|InnoDB|charset|not|null)”);
partes = reg.Matches(richTextBox1.Text.ToLower());
for (int i = 0; i < partes.Count; i++)
{
richTextBox1.SelectionStart = partes[i].Index;
richTextBox1.SelectionLength = partes[i].Length;
richTextBox1.SelectionColor = Color.Blue;
}
reg = new Regex(“(int|float|double|varchar|date)”);
partes = reg.Matches(richTextBox1.Text);
for (int i = 0; i < partes.Count; i++)
{
richTextBox1.SelectionStart = partes[i].Index;
richTextBox1.SelectionLength = partes[i].Length;
richTextBox1.SelectionColor = Color.Blue;
}

// Validamos los numero
reg = new Regex(“(1|2|3|4|5|6|7|8|9|0)”);
partes = reg.Matches(richTextBox1.Text);
for (int i = 0; i < partes.Count; i++)
{
richTextBox1.SelectionStart = partes[i].Index;
richTextBox1.SelectionLength = partes[i].Length;
richTextBox1.SelectionColor = Color.Magenta;
}
// Validamos cadenas
reg = new Regex(“[\"][^\"]*[\"]“);//|[\'][^\']*[\']“);
partes = reg.Matches(richTextBox1.Text);
for (int i = 0; i < partes.Count; i++)
{
richTextBox1.SelectionStart = partes[i].Index;
richTextBox1.SelectionLength = partes[i].Length;
richTextBox1.SelectionColor = Color.Orange;
}

// Validamos cadenas
reg = new Regex(“[\'/')][^\'/']*[\'/']“);
partes = reg.Matches(richTextBox1.Text);
for (int i = 0; i < partes.Count; i++)
{
richTextBox1.SelectionStart = partes[i].Index;
richTextBox1.SelectionLength = partes[i].Length;
richTextBox1.SelectionColor = Color.Gray;
}

// Regresamos todo a su sitio, también volvemos a habilitar el RichTextBox que fue desabilitado para evitar el parpadeo
richTextBox1.SelectionStart = selStart;
richTextBox1.SelectionLength = selLength;

richTextBox1.Enabled = true;
richTextBox1.Focus();

Obtendriamos el siguiente resultado:

Este pequeño tutorial esta basado en la sintaxis de MySql lo complejo de SyntaxHighlight depende de la sintaxis que te quieras basar y todo lo que quieras abarcar, como mencione anteriormente este es un tutorial sumamente sencillo basado en lo mas básico. 
Espero y les sea de ayuda!

Saludos a todos!
El día de hoy se llevó a cabo una reunión del grupo de Software Libre del IPN (Instituto Politécnico Nacional), a continuación les adjunto los puntos más importantes de la reunión, mientras suben la minuta oficial.

Minuta de UPIITA, UPIICSA, ESIME – Zacatenco, ESIME – Culhuacan

04/Sept/10

Integrantes

3 UPIITA
1 ESIME-Culhuacan
2 ESIME-Zacatenco

Temas

Soporte de IPN en Opensource
Objetivo claro de comunidad Libre – Impulsar a Vocacionales
Cursos de taller
UPIITA se distingue por Mecatronica- Mecatrónicos
Contactos de Industrias para dar incentivos
Tener un repositorio de información
Misión, Visión y Objetivos
Lista de Correos o IRC en servidor de Debian
Apoyarse del plan de estudios de la carrera para involucrar a la gente en Tecnologías Libres
Hacer imagen, Logotipo y eslogan de la comunidad

Objetivo de la comunidad
Divulgación de Software Libre (no tan técnica)

Misión

Impulsar la perspectiva cultural del usuario basándose en las 4 libertades de la filosofía del software libre para el desarrollo de sus actividades, promoviendo a su vez su desarrollo personal y profesional en equipo como miembro de una comunidad.

Conocer y fomentar filosofías, comunidades y herramientas técnicas en el uso y desarrollo de Tecnologías libres para todo tipo de usuarios.

Visión
Integración de las comunidades de tecnologías libres del IPN y México, siendo centro de documentación y divulgación, que promueve la colaboración de profesionistas, desarolladores, impulsores y participantes entusiastas a la vanguardia en tecnologías libres.

Objetivos
Integrar a todas las comunidades de tecnologías libres del IPN.
Impulsar a los miembros de la comunidad a utilizar y contribuir al desarrollo de tecnologías libres.
Crear vínculos con empresas y organizaciones (gubernamentales o no) para el propio impulso de la comunidad.
Inducir a las personas en el uso de tecnologías libres.
Generar nuevos proyectos de tecnologías libres.
Apoyo a otras comunidades.
Enriquecer el conocimiento de los integrantes.
Asesoría a usuarios.

Todos hemos visto en la última edición de Windows (Windows 7) la posibilidad de que en el escritorio se roten automaticamente una serie de imagenes que nosotros eligamos para que cambien cada cierto tiempo, bueno pues, en Ubuntu todo es posible y gracias a ello podemos empezar a crear nuestros propios fondos de escritorios con imagenes rotatorias de una manera sencilla, a continuacion explico los pasos que hay que seguir:

1. Lo primero que tenemos que hacer es abrir una terminal y ejecutar cada uno de los siguientes comandos como usuario root:

[shell]
sudo add-apt-repository ppa:crebs/ppa
sudo apt-get update
sudo apt-get install crebs
[/shell]

Esto instalará el repositorio CreBS, actualizará los paquetes disponibles y finalmente instalará CreBS. Una vez instalado

Ejecutamos crebs desde nuestra terminal :

[shell]
crebs
[/shell]

O desde : Sistema-> Preferencias -> Crear Presentacion de Fondos de Pantalla

Al ejecutar podemos ver la siguiente ventana:

Vamos a la parte inferior del programa y damos click en el signo + para poder agregar nuestras imagenes, las cuales formarán nuestro slideshow del escritorio:

Posteriormente elegimos las imagenes que queremos, podemos selecciona todas las imagenes de una vez:

Una vez que ya agregamos todas las imagenes, vamos a la parte de abajo del programa y en la pestaña: Image Defaults Deseleccionamos el checkbox “Usar predeterminado” para poder configurar el tiempo que cada imagen durará y el tiempo que tarda en realizar la transicion.

Si queremos especificar valores diferentes para cada imagen, seleccionan una imagen y se van a la pestaña Imagen seleccionada, desde la cual pueden configurar los valores para la imagen seleccionada:

Finalmente le damos un nombre y damos click en el botón de la palomita:

Nos aparecerá un mensaje, informandonos que nuestro fondo ha sido reeemplazado, y ahora podemos ver nuestro slideshow como fondo de escritorio:

Hasta aqui llegá este tutorial, espero que les haya servido, dudas, sugerencias, y opiniones en la sección de comentarios por favor.

El tutorial fue dedicado a mi blog es por eso que tiene esas marcas de agua, lo publico aqui para que mas personas tengan acceso al tutorial.

Antes de comenzar quiero mencionar que este tutorial fue basado en el tutorial “Modelado con Booleanas en Maya” que se encuentra en el blog “Capital 3D” a continuación el link del tutorial mencionado http://capital3d.blogspot.com/2008/07/modelado-con-booleanas-en-maya.html

Comencemos !!

1. Escojemos la vista Top, poniendo sobre ella el puntero del mouse y presionamos la barra espaciadora



2. Creamos el primer objeto, un cilindro, vamos a “Create / Poligon Primitives / Cilinder” damos clic en el cuadradito eso va permitir ver un ventana con opciones



3. En esta ventanita vamos a cambiar el “Axis Divisions” a 50 y el “Cap Divisions” a 0 después damos clic en “Create”



4. A continuación, presiona la tecla “f” para que te acerques bien al cilindro”



5. Presione “F9”, vas a ver unos puntos morados, selecciona todos los puntos de la derecha, hazlo de afuera hacia adentro



6. Ahora presiona “alt + clic derecho” del mouse y mueve el mismo hacia arriba para que puedas alejar un poco la vista, luego presiona la tecla “w” que sirve para activar la herramienta de mover y mueve esos puntos de manera que se alargue el objeto



7. Ahora, selecciona todos los puntos de la mitad para abajo y muévelos para ir formando la ficha de domino



8. Ve a “Create / Polygon Primitives / Cube” esto te va a crear un cubo



9. Así te tiene que quedar el cubo: largo, delgado y que solo este un poco metido en la parte de arriba de la ficha de domino, mira en las cuatro vistas usando la barra espaciadora y elije la vista “side” para que te quede igual que mi imagen



10. Regresa a la vista “top” y tiene que quedar así



11. Vamos al menú “Create / Polygons Primitives / Sphere” y hacemos haz clic en el cuadradito para que salga la ventana de opciones



12. Cambiamos los dos valores de subdivisión a 30 y luego presionamos el botón “Create”

13. Ahora ve a la vista “Side” y asegúrate que la esfera este saliendo de la mitad para arriba en relación a la ficha



14. Ahora vamos a copiar los objetos, cuando copies un objeto Maya te va a poner la copia exactamente en el mismo lugar del original así que debes mover la copia para poder verla, para copiar debes seleccionar el objeto original y luego “control + d”



15. Ve al menú “Mesh / Booleans / Union” esta herramienta sirve para pegar dos objetos, lo malo es que solo se pueden pegar objetos de dos en dos, une todas los objetos incluyendo el cubo menos la ficha de tal manera que quede como se muestra en la figura



16. Ahora vamos a darle color a los puntitos, mantenlos seleccionados y ve a la pestaña llamada “Rendering” y haz clic sobre la segunda esfera gris



17. En el “Editor de Atributos” que está a mano derecha vas a ver la opción llamada color presiona sobre ese cuadradito gris y una nueva ventana aparecerá, selecciona en ella el color que tú quieras, cuando estés listo presiona “Aceptar”



18. Ahora, selecciona la ficha, vuelve a hacer clic sobre la esferita gris de “Blinn” en la pestaña de “Render” y píntala (después de pintarla presionamos la tecla “5” para hacerlo solido)



19. Ahora seleccionamos la ficha y luego usando la tecla “Shift” selecciones los puntitos, cuando haces eso la ficha va a tener una orilla blanca y los puntitos una orilla verde indicándote que fueron los últimos en ser seleccionados



20. Vamos al menú “Mesh / Booleans / Difference”, los puntos cortan a la ficha



21. Vamos al menú “Modify / Center Pivot” y damos clic sobre el centro de la figura



22. Ahora giramos la ficha para poder levantarla, para que te aparezca la herramienta de girar presiona “e” o del lado izquierdo el icono “rótate tool” y nos vamos a la vista “perps”



23. Listo!! Ya tenemos nuestra figura terminada

Con esto damos por terminado el tutorial cualquier duda o pregunta estamos para ayudarles

Hola comunidad!, de regreso aportando más material para que esto siga en crecimiento.

Ahora presentando un pequeño programita hecho en C# que nos sirve para geolocalizar direcciones mediante google maps.

El programa lo dividí en tres clases:

Geocodign.- Es la parte donde se hace el proceso de geolocalización
Point.- Clase para identificar nuestras direcciones a geolocalizar
Principal.- Es la clase principal del proyecto

La clase Geocodign

Esta clase cuenta con tres métodos (GetXml, GetData, ChangeUrl)

El método GetXml nos regresa los datos en formato XML y lo guarda en un archivo, el XML es lo que nos manda el googlemaps.

El método GetData nos regresa un Hashtable con los datos dirección (address), longitud (longitude), latitud (latitude). Estos datos los extraemos del arhivo XML que se guarda con el GetXml.

El método ChangeUrl lo utilizamos para reemplazar los espaciós en blanco de la dirección a geolocalizar, por ejemplo “dirección a geolocalizar” por “dirección%20a%20geolocalizar”.

Usings

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Net;
using System.Xml;
using System.Xml.XPath;
using System.Windows.Forms;
using System.Collections;

class Geocoding
    {
        private string fileName = "datosxml.xml";
 
        public void GetXml(string address)
        {
            try
            {
                string url = String.Format("{0}", address);
                url = this.ChangeUrl(url);
                string lcUrl = String.Format("http://maps.google.com/maps/geo?q={0}&output=xml&sensor=true_or_false&key=your_api_key", url);
                HttpWebRequest loHttp =
                (HttpWebRequest)WebRequest.Create(lcUrl);
                loHttp.Timeout = 30000;     // 30 secs
                loHttp.UserAgent = "Code Sample Web Client";
                HttpWebResponse loWebResponse = (HttpWebResponse)loHttp.GetResponse();
                Encoding enc = Encoding.GetEncoding(1252);  // Windows default Code Page
                StreamReader loResponseStream = new StreamReader(loWebResponse.GetResponseStream(), enc);
                string lcHtml = loResponseStream.ReadToEnd();
 
                StreamWriter sw = new StreamWriter(fileName, false);
                sw.Write(lcHtml);
                sw.Close();
 
                loWebResponse.Close();
                loResponseStream.Close();
            }
            catch (Exception ex) {
                MessageBox.Show("Error " + ex.Message, "Error");
            }
 
        }
 
        public Hashtable GetData()
        {
            Hashtable data = new Hashtable();
            XPathDocument doc = new XPathDocument(fileName);
            string namespaceUri = "http://earth.google.com/kml/2.0";
            XmlNamespaceManager ns = new XmlNamespaceManager(new NameTable());
            XPathNavigator nav = doc.CreateNavigator();
            ns.AddNamespace("bz", namespaceUri);
            string query = "bz:kml/bz:Response/bz:Placemark/bz:Point/bz:coordinates";
            XPathNodeIterator iter = nav.Select(query, ns);
            string coordinates = (iter.MoveNext()) ? iter.Current.Value : "";
 
            query = "bz:kml/bz:Response/bz:Placemark/bz:address";
            iter = nav.Select(query, ns);
            string address = (iter.MoveNext()) ? iter.Current.Value : "";
 
            string lon = "";
            string lat = "";
            if (coordinates.Split(',').Length == 3)
            {
                lon = coordinates.Split(',')[0].ToString();
                lat = coordinates.Split(',')[1].ToString();
 
                data.Add("longitude",lon);
                data.Add("latitude", lat);
                data.Add("address", address);
            }
            else
            {
                data.Add("longitude", lon);
                data.Add("latitude", lat);
                data.Add("address", address);
            }
            return data;
        }
 
        private string ChangeUrl(string address)
        {
            address = address.Replace("#", "");
            address = address.Replace(" ", "%20");
            return address;
        }
    }

La clase Point

Esta clase cuenta con los atributos Address, Longitude y Latitude con sus respectivos métodos get y set.

Usings

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

class Point
    {
        private string longitude;
        private string latitude;
        private string address;
 
        public string Address
        {
            get
            {
                return this.address;
            }
            set
            {
                this.address = value;
            }
        }
 
        public string Longitude
        {
            get
            {
                return this.longitude;
            }
            set
            {
                this.longitude = value;
            }
        }
 
        public string Latitude
        {
            get
            {
                return this.latitude;
            }
            set
            {
                this.latitude = value;
            }
        }
    }

La clase Principal

Para nuestro caso la clase principal es la de nuestro formulario, donde tendremos dos textbox (txtaddress y txtdata), en el txtaddress pondremos la dirección a geolocalizar y en el txtdata obtendremos nuestros datos, también tendremos un boton (btngeocoding) con el cual daremos la acción para realizar la geolocalización.

Formulario principal

El código del botón es el siguiente

Usings

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Xml;
using System.Xml.XPath;
using System.IO;

        private void btngeocoding_Click(object sender, EventArgs e)
        {
            string address = this.txtaddress.Text;
            Geocoding geocodign = new Geocoding();
            Point point = new Point();
 
            geocodign.GetXml(address);
            Hashtable data = geocodign.GetData();
 
            point.Address = data["address"].ToString();
            point.Longitude = data["longitude"].ToString();
            point.Latitude = data["latitude"].ToString();
 
            this.txtdata.Clear();
            this.txtdata.Text = String.Format("{0}Dirección= {1} \r\n", this.txtdata.Text, point.Address);
            this.txtdata.Text = String.Format("{0}Longitud= {1} \r\n", this.txtdata.Text, point.Longitude);
            this.txtdata.Text = String.Format("{0}Latitud= {1} \r\n", this.txtdata.Text, point.Latitude);
        }

Ejemplo:

Ejemplo

Espero sea de grán ayuda! Dudas ó sugerencias, no duden en hacerlas llegar. Estamos para servir.. Saludos!

Para instalar Gnokii en nuestro servidor usamos el administrador de paquetes apt con la siguiente linea: apt-get install gnokii Si estamos sobre Ubuntu recuerden anteponer la linea sudo

Una vez instalado Gnokii tenemos que configurarlo, el primer paso es  entrar a la carpeta etc  con la siguiente línea de comando: cd /etc
Cuando estemos dentro de etc el siguiente paso será editar el archivo gnokiirc para esto utilizamos el siguiente comando: nano gnokiirc

Una vez que nos encontremos en el editor en la parte [global]  agregaremos las líneas correspondientes al tipo de cable que usa nuestro teléfono  en este caso quedara de la siguiente manera  (recuerda que esta configuración es para un Nokia 5610 que utiliza un cable tipo CA-101 para  ver las configuraciones de otro tipo de cables consulta http://wiki.gnokii.org/index.php/Cables)

[global]
model = AT
port = /dev/ttyACM0
connection = serial

Una vez que hayamos editado y guardado el archivo gnokiirc conectamos nuestro teléfono al equipo y elegimos la opción PC Suite y ejecutamos el siguiente comando: gnokii –identify

Una vez que hayamos editado y guardado el archivo gnokiirc conectamos nuestro teléfono al equipo y elegimos la opción PC Suite y ejecutamos el siguiente comando: gnokii –identify
Nos tendrá que mostrar  todos los datos de nuestro teléfono

Nota: Por razones de seguridad edite la parte del IMEI

Ahora está configurado y listo para enviar mensajes

Para probar la funcionalidad del envió de mensajes la sentencia a ejecutar es la siguiente:

echo “Hola mundo” | gnokii –sendsms numerocelular

Nota: por razones de seguridad he editado la pare correspondiente al numero telefónico

Una vez que se halla enviando el mensaje correctamente aparecerá un mensaje de que todo ha salido bien en caso contrario nos mostrara el mensaje failed

con esto damos por concluido este tutorial , cualquier duda o sugerencia estamos para ayudarles

La instalación de Processing es muy sencilla si se cuanta con los materiales necesarios, solo es cuestión de seguir unos simples pasos:

Paso 1: Descargar Processing

Descargamos el Processing de la pagina oficial y nos aseguramos que sea la versión para Mac OS X http://www.processing.org/download/, y se guarda donde sea mas conveniente.

Paso 2: Ejecutar el Archivo Descargado

Cuando la descarga se complete ejecutamos el archivo .dmg y aparecerá una ventana como la siguiente.

Paso 3: Instalación en Mac OS X

Arrastramos el icono de Processing encima de la carpeta Aplicaciones, cuando esta se habrá soltamos el icono dentro y esperamos que termine de copiarse.

Paso 4: Final de la Instalación

Una vez hecho lo anterior desmontamos el archivo .dmg, con clic derecho expulsar, luego nos dirigimos a nuestra carpeta de aplicaciones y ejecutamos el Processing.

Nota:

Lo que se utilizo para este tutoríal fue el Processing 1.0 y una MacBook Pro con Mac Os X