Programación y Fotografía

Revisar en un trigger si un campo con valor predeterminado CURRENT_TIMESTAMP tiene valor

2015-06-08T09:25:00.000-07:00

Problema:
Se intenta revisar el valor que trae un registro que se acaba de guardar, no se le asigna un valor a un campo Fecha en la inserción ya que tiene configurada en la tabla como valor predeterminado un CURRENT_TIMESTAMP, lo que se requiere es que al momento de insertarlo se verifique que:
1) Es un registro nuevo (no se le puso fecha y se toma el CURRENT_TIMESTAMP)
2) En caso de que tenga asignado una fecha diferente a la actual no tomarlo en cuenta para un segundo proceso.
3) Se usará un trigger BEFORE INSERT

Solución.

if (cast(New.Fecha as date) = curdate()) or New.Fecha is null or NEW.Fecha = '0000-00-00 00:00:00' then
//Proceso en caso de ser nuevo o fecha actual
end if

El error que tenía antes de encontrar ésto era que suponía que si no se declara un valor en el campo Fecha entraba al trigger con valor NULL, lo cual es incorrecto ya que trae un valor de '0000-00-00 00:00:00' y éste no lo había considerado en la sentencia de evaluación.

Ejecutando programas externos desde .Net

2013-08-24T06:29:00.000-07:00

Dada la necesidad de ejecutar un programa hecho en Java desde consola usando .Net con Visual Basic me puse un poco a investigar dada mi falta de experiencia en eso. Después de no mucho tiempo (2 minutos) encontré la solución resolviendo el problema de "ocultar" la ventana MS-DOS que aparece al ejecutar el programa:

Dim proceso As New System.Diagnostics.ProcessStartInfo

'Colocamos la ruta del programa a ejecutar, o comando

proceso.FileName = "java"

'Agregamos los parámetros de ejecución

Dim argumentos As String = "-jar ejecuta.jar"

proceso.Arguments = Argumentos

'Ponemos las condiciones para que se oculte la ventana al invocar el proceso

proceso.WindowStyle = ProcessWindowStyle.Hidden

proceso.CreateNoWindow = True

'Iniciamos el proceso en un nuevo hilo

Process.Start(proceso)

Ojalá les sirva para sus proyectos

¿Qué intentaba arreglar cada lenguaje de programación?

2013-07-20T06:06:00.000-07:00

Tomado de mundogeek.net

En su artículo What Languages Fix, Paul Graham, autor de Hackers & Painters y fundador de Y Combinator examinaba hace unos años algunos de los lenguajes de programación más conocidos desde una óptica interesante: los problemas que sus creadores intentaban solucionar al crearlos.

Hoy me he vuelto a encontrar con este texto y he dedicado unos minutos a traducirlo y a crear una representación gráfica en forma de línea de tiempo que podéis ver a continuación.

Algol: Ensamblador trabaja a muy bajo nivel
Pascal: Argol no tiene suficientes tipos de datos
Modula: Pascal es limitado para programación de sistemas
Simula: Algol no es lo bastante bueno para simulaciones
Smalltalk: No todo en Simula es un objeto
Fortran: Ensamblador trabaja a muy bajo nivel
Cobol: Fortran da miedo
PL/1: Fortran no tiene suficientes tipos de datos
Ada: A todos los lenguajes que existen les falta algo
Basic: Fortran da miedo
APL: Fortran no es lo bastante bueno manipulando arrays
J: APL requiere su propio juego de caracteres
C: Ensamblador trabaja a muy bajo nivel
C++: C trabaja a muy bajo nivel
Java: C++ es una chapuza. Y Microsoft nos va a aplastar
C#: Sun controla Java
Lisp: Las máquinas de Turing son una forma extraña de describir computación
Scheme: MacLisp es una chapuza
T: Scheme no tiene librerías
Common Lisp: Hay demasiados dialectos de Lisp
Dylan: Scheme no tiene librerías, y la sintaxis de Lisp da miedo
Perl: Los shell scripts/awk/sed no parecen lenguajes de programación
Python: Perl es una chapuza
Ruby: Perl es una chapuza, y la sintaxis de Lisp da miedo
Prolog: La programación no se parece lo suficiente a la lógica

Modelo de cajas en CSS

2013-07-16T19:31:00.000-07:00

Traducción de boxmodel:
Todos los elementos HTML son considerados como cajas. En CSS, el término "modelo de caja" o "box model" es usando al hablar del diseño y bosquejo.
El model de caja CSS es esencialmente una caja que se muestra alrededor de elementos HTML, el cual consiste de: márgenes, bordes, relleno y el contenido,
El modelo de caja nos permite colocar un borde alrededor de los elementos y espacio en relación a otros elementos.
El modelo se puede ver como la siguiente imagen:

Donde:

Margen (Margin): Es el espacio alrededor del borde. El margen no tiene color de fondo, es completamente trasnparente.

Borde (Border): Es el espacio alrededor del relleno y del contenido. El borde es afectado por el fondo de la caja.

Relleno(Padding): Es el espacio alrededor del contenido. El relleno es afectado por el color de fondo de la caja.

Contenido(Content): Es el contenido de la caja, donde se muestran las imágenes y el texto.

Menú circular

2013-07-15T19:03:00.000-07:00

Buscando ideas para crear un menú para la página www.llacuadetetique.com me topé con ésta bonita idea, la cual es crear un menú circular:

Donde el código para ponerlo en nuestra web la podemos encontrar en: codigo

Iglesia

2013-07-10T17:05:00.001-07:00

Borrado de triggers de una base de datos mysql

2013-07-10T11:53:00.000-07:00

En ocasiones cuando creamos triggers para llevar a cabo tareas inmediatas desde la base de datos y creamos triggers, sucede que después de un tiempo (1 semana) se nos olvida el nombre de los triggers creados.

Éste problema conlleva a que si necesitamos subirlos de nuevo o simplemente borrarlos no podemos hacerlo hasta recordar el nombre (si es que nos acordamos). Una forma rápida de ver que triggers tenemos y de obtener la consulta para borrarlos es la siguiente:

select concat('drop trigger ', trigger_name, ';') from information_schema.triggers where trigger_schema = 'your_database'

donde your_database es sustituido por el nombre de la base de datos donde se encuentran los triggers. Obtenido de http://stackoverflow.com

Como resultado nos dara los sqls necesarios para borrar los triggers que tenemos o en su caso para ver sus nombres.

Podemos ejecutar éste sql desde consola de Mysql o desde el PhpMyAdmin.

Crear código SQL en Java a partir de una consulta

2013-07-08T21:34:00.000-07:00

En una ocasión tuve la necesidad de respaldar ciertos datos de una base de datos MySql, los usuarios del programa tenian que generar a partir de una consulta los datos a exportar. De ésta forma tuve que buscar la manera de crear el código de inserción a la base de datos a partir de un conjunto de datos obtenidos a partir de una consulta a la BD.

El caso es el siguiente: Se tiene una consulta X, se requiere guardar a un archivo la exportación de la consulta y conocemos el nombre de la tabla de la cual se extrajo la información.
El primer procedimiento era usar las mismas herramientas que proporciona MySQL para llevar a cabo la exportación, solo que no todas las máquinas que usaban el programa se les podia instalar los ejecutables necesarios para llevar éste método; así que se decidió que se hiciera de forma plana (SQL) en archivos de textos importables a la Base de Datos final.

El método que se creo fue el siguiente:

    /**

     * Método que crea cadenas insert para cada datos leido de una consulta

     * @param entrada Consulta a crear los inserts

     * @param archivo Ruta del archivo a escribir

     * @param tabla Nombre de la tabla donde se insertaran los datos

     * @return Si se pudo o no realizar la conversión

     */

    public boolean creaInsert(ResultSet entrada, String archivo, String tabla) {

        try {

            ResultSet salidaRS = entrada;

            ResultSetMetaData rsmd = salidaRS.getMetaData();

            String consulta = "";

            consulta = "insert into " + tabla + " (";

            for (int k = 1; k < rsmd.getColumnCount(); k++) {

                consulta = consulta + rsmd.getColumnName(k + 1) + ",";

            }

            consulta = consulta.substring(0, consulta.length() - 1) + ") VALUES(";

            for (int k = 1; k < rsmd.getColumnCount(); k++) {

                if (rsmd.getColumnTypeName(k + 1).contains("INTEGER")) {

                    consulta = consulta + "" + salidaRS.getString(k + 1) + ",";

                } else if (salidaRS.getString(k + 1) == null || salidaRS.getString(k + 1).contains("null") || salidaRS.getString(k + 1).contains("----")) {

                    consulta = consulta + "null,";

                } else {

                    consulta = consulta + "'" + salidaRS.getString(k + 1) + "',";

                }

            }

            consulta = consulta.substring(0, consulta.length() - 1) + ");";

            File f;

            f = new File(tabla + ".txt");

            if (!f.exists()) {

                f.createNewFile();

            }

            escribeArchivo(tabla, consulta);

            return true;

        } catch (Exception a) {

            a.printStackTrace();

        }

        return false;

    }

De ésta forma se crea un archivo que contiene los inserts correspondientes a la consulta pasada como parámetro.

Google recordandote

2013-07-06T06:52:00.000-07:00

Que buen detalle de google, la verdad no sabía que hacía este tipo de cosas. Un gran punto a su favor :D

Edad en Dias Meses Años usando java y mysql

2013-07-05T21:19:00.000-07:00

En ocasiones es necesario saber la edad de una persona en cierta fecha, para esto existen diversas alternativas dependiendo de las herramientas con las que contamos.
En ésta ocasión les muestro la forma de hacerlo usando Java y una conexión a una base de datos MySql.
Para que el método descrito aqui funcione es necesario que se cuente con la conexión MySql ya creada y conectada y las fechas inicial y final. La fecha inicial puede ser la fecha de nacimiento y la final la fecha actual.
Para que el método sea lo mas amplio posible se pasa como parámetro ambas fechas.

public ResultSet DMAdiferencia(String inicio, String fin) {
try {
ResultSet diferencia = this.derby.createStatement().executeQuery(""
+ "SELECT   {fn TIMESTAMPDIFF(SQL_TSI_YEAR,{ts '" + inicio + " 00:00:00' },{ts '" + fin + " 00:00:00'}) } AS ANIOS, "
+ " ( ( {fn TIMESTAMPDIFF(SQL_TSI_MONTH,{ts '" + inicio + " 00:00:00'},{ts '" + fin + " 00:00:00'})}) -  ( {fn TIMESTAMPDIFF(SQL_TSI_YEAR,{ts '" + inicio + " 00:00:00'},{ts '" + fin + " 00:00:00'}) } * 12)) AS MESES, "
+ " -( {fn TIMESTAMPDIFF(SQL_TSI_DAY,{ts '" + fin + " 00:00:00'},"
+ "         {fn TIMESTAMPADD ( SQL_TSI_MONTH,"
+ "              (({fn TIMESTAMPDIFF(SQL_TSI_MONTH,{ts '" + inicio + " 00:00:00'},{ts '" + fin + " 00:00:00'})}) - ( {fn TIMESTAMPDIFF(SQL_TSI_YEAR,{ts '" + inicio + " 00:00:00'},{ts '" + fin + " 00:00:00'})  } )* 12 ),"
+ "             {fn TIMESTAMPADD( SQL_TSI_YEAR,"
+ "                 ({fn TIMESTAMPDIFF(SQL_TSI_YEAR,{ts '" + inicio + " 00:00:00'},{ts '" + fin + " 00:00:00'})}), {ts '" + inicio + " 00:00:00'} "
+ "             )}"
+ "         )}"
+ "     )"
+ "}) "
+ "AS DIAS");
return diferencia;

} catch (Exception a) {
a.printStackTrace();
}
return null;
}

Como resultado de éste método se retorna un tipo de dato ResultSet que contiene tres columnas: DIAS, MESES, ANIOS en caso de que no pasara error alguno. El uso del método puede ser mas o menos así:

ResultSet salida= DMAdiferencia("2013-01-01","2013-12-12");

int dias= salida.getInt("DIAS");

int meses=salida.getInt("MESES");

int anios= salida.getInt("ANIOS");

Ojo, la fecha debe estar en formato YYYY-MM-DD.

Espero que les sirva para sus proyectos

Cálculo de CRIP (Clave de Registro e Identidad Personal)

2013-07-01T13:09:00.000-07:00

Código para generar la CRIP, usada normalmente en las actas de nacimiento y como parte de la CURP

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package utils;

/**
 *
 * @author cabachu
 */
import java.io.*;
import java.util.*;
// calcula el digito verificador de la CRIP para siglo pasado y el siglo actual 
// necesita tomar los valores de entidad, municipio, oficialia, acta y año 
//regresa un string que contiene la CRIP 
public class CalculaCrip {

    public String obtener_crip(
            String strEntidad,
            String strMunicipio,
            String strOficialia,
            String strAnio,
            String strActa) {
        String strdatos = "";
        String strletras = "JABCDEFGHIJ ";  // constantes de letras 
        String strnumeros = "012345678900";// constantes de numeros
        int ik[] = {3, 2, 7, 6, 5, 4, 3, 2, 7, 6, 5, 4, 3, 2}; // constante para calcular la crip 
        int[] imul = new int[16];
        int[] inum = new int[16];
        int isuma = 0;
        int ix = 0;
        int ia = 0;
        int idigito = 0;
        if (strEntidad.length() == 1) {
            strEntidad = "0" + strEntidad;
        } // se agrega un cero si vien 1 solo digito 
        if (strMunicipio.length() == 1) {
            strMunicipio = "00" + strMunicipio;
        }// se agregan ceros hasta copletar 3 digitos 
        if (strMunicipio.length() == 2) {
            strMunicipio = "0" + strMunicipio;
        }
        if (strOficialia.length() == 1) {
            strOficialia = "0" + strOficialia;
        }// se agregan ceros hasta copletar 2 digitos 
        if (strActa.length() == 1) {
            strActa = "0000" + strActa;
        }// se agregan ceros hasta copletar 5 digitos 
        if (strActa.length() == 2) {
            strActa = "000" + strActa;
        }
        if (strActa.length() == 3) {
            strActa = "00" + strActa;
        }
        if (strActa.length() == 4) {
            strActa = "0" + strActa;
        }
strdatos = strEntidad + strMunicipio + strOficialia + strAnio.substring(2, 4) + strActa; // se contatena la raiz para calcular el digito
        System.out.println(strdatos);
// a cada numero de la raiz se le multiplica por un nuemro de la constante y se suman 
        for (ia = 0; ia < 14; ia++) {
            inum[ia] = Integer.valueOf(strdatos.substring(ia, ia + 1)).intValue();
            imul[ia] = inum[ia] * ik[ia];
            isuma = isuma + imul[ia];
        }
// se obtiene el digito verificador 
        ix = isuma % 11;
        System.out.println("suma  ");
        System.out.println(isuma);
        System.out.println("digito antes de resta ");
        System.out.println(ix);
        if (ix <= 0) {
            idigito = 0;
        } else {
            idigito = 11 - ix;
        }
// se evalua el año y se coloca el digito verificador numero o letra 
        System.out.println("valor de comparacion");
        System.out.println(strAnio.compareTo("1999"));
        if (strAnio.compareTo("1999") > 0) {
            if (idigito == 0) {
                strdatos = strdatos + "J";
            } else {
                System.out.println(idigito);
                strdatos = strdatos + strletras.substring(idigito, idigito + 1);
            }
        } else {
            System.out.println(idigito);
            strdatos = strdatos + strnumeros.substring(idigito, idigito + 1);
        }
        System.out.println(strdatos);
        return strdatos;

    }
}

RFC y CURP en Java

2013-06-28T17:18:00.003-07:00

RFC

El Registro Federal de Contribuyentes (o RFC) se refiere a una clave que tiene, toda persona física en México para realizar alguna actividad licita que este obligada a pagar impuestos a toda persona moral con algunas excepciones. A estas personas se les llama contribuyentes.

Esta clave debe llevar datos personales del contribuyente o persona física como su nombre y fecha de nacimiento; o nombre y fecha de origen de la persona moral. El registro se debe hacer en las oficinas del Servicio de Administración Tributaria de la Secretaria de Hacienda y Crédito Publico, y es obligatorio para todos los que señale el Código Fiscal de la Federación.

(http://es.wikipedia.org/wiki/Registro_Federal_de_Causantes_(M%C3%A9xico))

Como saber el RFC de una persona fisica?

Para la Persona física: HECU871219 XXX

o Las primeras dos letras (HE) son el apellido paterno más la primera vocal interna del apellido paterno.

o El tercer dígito (C) es la inicial del apellido materno. De no existir un apellido materno se utiliza una (X).

o El cuarto dígito (U) es la inicial del primer nombre.

o Los primeros dos dígitos son el año de nacimiento (87).

o Los segundos dígitos son el mes de nacimiento (12 o Diciembre).

o Los terceros dígitos son el día de nacimiento (19).

Los últimos dígitos (XXX) se le conoce como homoclave, esta la designa el SAT, dependiendo de algunos factores que realiza el SAT por medio de sistemas numéricos o alfanuméricos.

Esta homoclave la designará el SAT, revisando la petición a través de papel oficial ya designado.

Cual es el RFC de una persona moral?

REN 550504 XXX

o Las primeras tres letras (REN) a veces son las iniciales de la empresa si se llega al caso o se hace una combinación de éstas.

o Los primeros dos dígitos son el año de fundación de la empresa (55).

o Los segundos dígitos son el mes de la creación de la empresa (05 o mayo).

o Los terceros dígitos son el día de la creación de la empresa (04).

Los últimos dígitos (XXX) son conocidos como homoclave, esta la designa el SAT, dependiendo de algunos factores que realiza el SAT por medio de sistemas numéricos o alfanuméricos.

(http://www.webadiccion.com/como-crear-mi-rfc/)

El RFC Original lo puedes obtener desde: https://www.recaudanet.gob.mx/recaudanet/rfc.jsp

CURP

La Clave Única de Registro de Población (CURP) es un código alfanumérico único de identidad de 18 caracteres, tanto para residentes como para ciudadanos mexicanos.

Con 18 elementos representados por letras y números, que se generan a partir de los datos contenidos en tu documento probatorio de identidad (acta de nacimiento, carta de naturalización o documento migratorio), y que se refieren a:

· Tu primer y segundo apellidos, así como tu nombre de pila.

· Tu fecha de nacimiento.

· Sexo.

· Entidad Federativa o lugar de nacimiento.

Los dos últimos elementos de tu CURP te los asigna el Registro Nacional de Población y evitan duplicaciones en la Clave, identifican el cambio de siglo y garantizan la correcta integración. Ejemplo:

Los dos últimos dígitos, garantizan que tu clave sea única, esto es, que sólo sea para una persona y se evite la duplicidad cuando haya dos nombres iguales en una misma entidad, porque es más difícil que coincidan la homoclave y el elemento verificador.

Siglas para las entidades federativas de nacimiento:

ESTADO	CLAVE	ESTADO	CLAVE
AGUASCALIENTES	AS	MORELOS	MS
BAJA CALIFORNIA	BC	NAYARIT	NT
BAJA CALIFORNIA SUR	BS	NUEVO LEON	NL
CAMPECHE	CC	OAXACA	OC
CHIAPAS	CS	PUEBLA	PL
CHIHUAHUA	CH	QUERETARO	QT
COAHUILA	CL	QUINTANA ROO	QR
COLIMA	CM	SAN LUIS POTOSI	SP
DISTRITO FEDERAL	DF	SINALOA	SL
DURANGO	DG	SONORA	SR
GUANAJUATO	GT	TABASCO	TC
GUERRERO	GR	TAMAULIPAS	TS
HIDALGO	HG	TLAXCALA	TL
JALISCO	JC	VERACRUZ	VZ
MEXICO	MC	YUCATÁN	YN
MICHOACAN	MN	ZACATECAS	ZS

Notas:
1) Para adoptar las iniciales de los apellidos no se toman en cuenta las preposiciones De, Del, Y, Van, Von, Der, Mc, entre otras.

2) Para los mexicanos nacidos en el extranjero, así como para los extranjeros residentes en el país, se utilizará como entidad de nacimiento la clave "NE"= nacido en el extranjero.

(http://www.condusef.gob.mx/index.php/clave-unica-de-registro-de-poblacion-curp)

Para Obtener la CURP original lo puedes hacer desde: http://consultas.curp.gob.mx/CurpSP/

Ahora que conocemos la definición y cómo se obtiene el RFC y CURP les traigo un código hecho en Java que obtiene ambos.

Anexo tanto el proyecto hecho en NetBeans, código fuente y JAR ejecutable para que puedan hacer uso de éste.

Cabe resaltar que éste pequeño programa no siempre obtiene al 100% el RFC o CURP dado que el cálculo de la Homoclave no siempre es correcto al no conocer algunos factores que son intuidos.

Sin embargo, sirve como una pequeña aplicación para darnos una idea de cual sería el RFC y CURP.

Espero que sea de utilidad y que sirva para sus proyectos.

Proyecto en NetBeans

Archivo Jar ejecutable

Utilidades

2013-06-28T16:42:00.000-07:00

En muchas ocasiones requerimos de pequeñas rutinas que son un dolor de cabeza. A veces éstas rutinas son reutilizables en más de una ocasión.

En mi caso existen algunas rutinas que aunque no han causado mucho problema al crearlas resultan ser muy útiles a la hora de crear aplicaciones.

El dia de hoy comparto una clase con algunas de éstas rutinas las cuales son:

stringToMoneda. Método que sirve para convertir un número double a su forma monetaria: Por ejemplo: 1325.35= $1,325.35

primerLetraMayuscula. Rutina que sirve para cambiar la primer letra en mayúscula. Muy útil cuando tenemos un nombre en puras minúsculas y queremos poner la primer letra en mayúscula.

pesosAPalabras. Rutina que cambia un double en su referente a pesos en letra P. Ej. $100 = cien pesos 00/100 M.N.

Descargar Clase

Algoritmos Genéticos

2013-06-28T15:48:00.004-07:00

Los algoritmos genéticos tienen su origen en la simulación de la Evolución. La evolución es el proceso en el cual los genes heredados de dos padres aptos son modificados, mejorados o mutados de tal forma que los nuevos individuos son mejores genéticamente hablando.

El proceso de mejoramiento se lleva a cabo al unir dos genotipos para producir un tercero. El genotipo son todas las características que componen al individuo (color de piel, color de cabello, tipo de ojos, tamaño de dientes, etc). Cuando se mezclan dos individuos (dos genotipos), existen diversas combinaciones que se pueden producir dependiendo de la misma mezcla y de los mismos genes que tengan los individuos.

A partir de estas mezclas se busca que los nuevos individuos sean cada vez más aptos en su medio ambiente y que su sobrevivencia sea posible.

En Computación, existen algunos problemas que pueden ser resueltos utilizando la teoría de Algoritmos Genéticos. En éste caso el individuo es la representación vectorial de una posible solución al problema planteado.

La evolución se lleva a cabo combinando los individuos o población base, de tal forma que en cada generación obtengamos mejores resultados.

El proceso de evolución de un Algoritmo Genético se puede plantear de a siguiente forma:

Se cuenta con una serie de individuos (vectores) que representarán soluciones parciales o soluciones no óptimas obtenidas por algún método de fuerza bruta o un algoritmo simple, dependiendo del problema será la forma en que se generará ésta primer generación de la población.

Posteriormente se deben evaluar cada uno de los individuos mediante alguna función de evaluación que nos permita saber que tan “buena” es la solución planteada. A partir del resultado de ésta evaluación llevaremos a cabo el ordenamiento de los mismos del mejor adaptado al peor.

Supongamos que generamos 100 individuos de forma aleatoria o mediante un algoritmo simple, usaremos los primero 40 individuos (los más aptos) para que se reproduzcan mientras que los restantes 60 serán eliminados.

A partir de la segunda generación, la obtención de la población se realizará mediante dos métodos:

- Cruza de los más aptos.

- Generación aleatoria o con algoritmos simples.

La cruza de los individuos se puede realizar de la siguiente forma:

Donde los dos hijos que se obtienen son resultado de la combinación de los padres por la mitad.

Otra forma de cruza puede ser:

Donde los individuos obtenidos son la combinación de un gen del padre y un gen de la madre de forma alternada.

De esta manera existen muchas combinaciones para que a partir de dos padres podamos obtener una serie de hijos resultados de la cruza de éstos.

A partir de 40 individuos aptos, podemos generar, por ejemplo, otros 100 individuos, que junto con los padres son la nueva generación. De igual forma se pueden generar nuevos individuos absolutamente nuevos a partir de generación aleatoria o usando algoritmos simples.

Ésta nueva generación se debe evaluar y de nuevo obtener los “más aptos”. Éste proceso de evaluación, generación, eliminación y cruza se debe llevar a cabo hasta que se obtenga una solución que se encuentre dentro de los parámetros requeridos o hasta alcanzar una cantidad de generaciones X.

Veremos un ejemplo de aplicación en un siguiente Artículo.

Abrir un archivo PDF desde una aplicación hecha en JAVA

2013-06-28T15:44:00.001-07:00

Realizando una aplicación se requería que se abriera un archivo PDF creado en la misma aplicación. El primer acercamiento fue usar

Process p = Runtime.getRuntime().exec("C:/Program Files/Adobe/Reader 8.0/Reader/AcroRd32.exe "+ "archivo.pdf");

El problema de usar de ésta forma la ejecución de Acrobat Reader es que no siempre se encuentra en la misma ubicación por las diferentes versiones que pueden existir.

Así que la forma encontrada y vista aqui se plantea la solución de la siguiente forma:

Process p = Runtime.getRuntime().exec("cmd.exe /c start "+ "archivo.pdf");

El cual ejecuta el Acrobat Reader abriendo el archivo.pdf de forma satisfactoria.

OpenCv

2010-09-28T16:56:00.000-07:00

Como parte de las herramientas que se cuentan en el manejo de imágenes se encuentra OpenCv. Su manejo es relativamente fácil si sólo se requiere abrir, manipular y guardar el resultado, lo cual mostraremos a continuación.

#include <cstdlib>
#include <iostream>
#include <cv.h>
#include <highgui.h>
#include <math.h>

using namespace std;

int main(int argc, char** argv) {
//Abrir

IplImage* img=cvLoadImage("entrada.bmp");

if(!img){
   printf("Could not load image file: %s\n",img);
   exit(0);
}

int height = img->height; //Alto
int width = img->width; //Ancho
int step = img->widthStep/sizeof(uchar); //Tam paso
int channels = img->nChannels; //Numero de canales p.e. 3=RGB
uchar *data = (uchar *)img->imageData; //Valores de la imagen

//Manipulando -Invirtiendo colores
int i,j,k;
for(i=0;i<height;i++){
   for(j=0;j<width;j++){
   for(k=0;k<channels;k++){
   data[i*step+j*channels+k]=256-data[i*step+j*channels+k];
   }
   }
}

//Guardando

img->imageData=(char *) data;
cvSaveImage("salida.bmp",img);

}

La libreria se puede descargar desde: http://sourceforge.net/projects/opencvlibrary/

Segmentación de Imágenes usando redes de Kohonen

2010-09-27T16:45:00.000-07:00

La segmentación es un proceso en el cual un objeto es dividido en diferentes zonas o regiones dependiendo de sus características. En una imagen, la segmentación se puede llevar a cabo a partir de intensidades de color, forma, contornos, etc.

Las redes neuronales han sido una herramienta que por su simpleza en implementación se han utilizado frecuentemente para resolver diversos problemas.

Aquí se muestra una forma de llevar a cabo la segmentación de una imagen, usando los principios de las redes neuronales artificial mediante un aprendizaje no supervisado.

Los mapas de rasgos autoorganizados o SOFM (Self – Organizing Features Maps) fueron desarrollados a lo largo de la década de los 80´s por el físico finlandés Teuvo Kohonen [1], como una continuación natural de la línea de desarrollo de las redes competitivas iniciada por von der Malsburg. Además de ser una sencilla modernización de redes neuronales naturales poseen gran potencial de aplicabilidad práctica. De entre las clases de problemas del mundo real en los que han demostrado su eficacia cabe citar: clasificación de patrones, cuantificación vectorial, reducción de dimensiones, extracción de rasgos, monitoreo de procesos, análisis exploratorio, visualización y minería de datos[2].

Se debe tener en cuenta que no existe un algoritmo de aprendizaje totalmente estándar para los SOM. No obstante, el resultado final es bastante independiente de los detalles de su realización concreta, como pueden ser los pesos sinápticos de partida, el esquema de la actualización del ritmo de aprendizaje o la forma establecida para la vecindad. El algoritmo autoorganizado habitual es [2]:

1. Inicialización de los pesos sinápticos W[i,j,k]. Se puede partir de diferentes configuraciones: pesos nulos, aleatorios de pequeño valor absoluto (lo más habitual), o con un valor de partida predeterminado.

2. En cada iteración, se presenta un patrón x(t) tomado de acuerdo con la función de distribuición p(x) del espacio sensorial de entrada (en la muy habitual situación de disponer solamente de un conjunto finito de patrones de entrenamiento, basta con tomar al azar uno de ellos y presentarlo a la red).

3. Cada neurona i=(i,j) del mapa calcula la similitud entre su vector de pesos sináptico y el actual vector de entradas . Un criterio de medida de similitud muy utilizado es la distancia Euclidiana: d^2(w[i,j],x)(t+1)=SUM(w[i,j,k]-x[k])^2

4. Determinación de la neurona ganadora g, cuya distancia es la menor de todas.

5. Actualización de los pesos sinápticos de la neurona ganadora g, y los de sus neuronas vecinas. La regla más empleada de todas es: w[i,j,k](t+1)=w[i,j,k]+alfa(t)h(i-g,t)(x[k](t)-w[i,j,k](t))

donde alfa(t) es un parámetro denominado coeficiente o ritmo de aprendizaje. La función h() se denomina función de vecindad, puesto que establece qué neuronas son las vecinas a la actualmente ganadora. Esta función depende de la distancia entre la neurona i y la ganadora g valiendo cero cuando i no pertenece a la vecindad de g (con lo que sus pesos no son actualizados), y un número positivo cuando sí pertenece (sus pesos si son modificados). Como veremos, la vecindad es un conjunto de neuronas centrado en la ganadora. Tanto como el radio de la vecindad disminuye monótamente con , es decir se conserva un orden.

6. Si se ha alcanzado el número máximo de iteraciones establecido, entonces el proceso de aprendizaje finaliza. En caso contrario, se vuelve al paso 2.

Como se puede apreciar el aprendizaje es una regla simple, sin embargo ahora se explicará como se aplica en una imagen:

Supongamos que tenemos una imagen de 1024x1024 pixeles en formato RGB. Vamos a usar una máscara de 5x5 pixeles, la cual puede variar dependiendo de nuestra aplicación. Antes del procesamiento, la imagen debe ser normalizada a valores entre 0 y 1, ésto se logra de la siguiente forma:

Por cada píxel multiplicamos los tres valores de RGB y lo dividimos entre 16777216.

Las redes de kohonen de una dimensión requieren de entrada un vector de una dimensión por lo cual, nuestra máscara será convertida de una matriz de 4x4 a un vector de 16 valores.

Por cada píxel de la imagen se obtendrá una máscara, donde el píxel será el centro de la misma.

Dependiendo de en cuantas regiones queremos segmentar nuestra imagen, serán el número de clases a considerar.

Como en todas las redes neuronales, éstas deben ser entrenadas, para ello, usaremos la regla de aprendizaje de Kohonen, con lo cual inicializamos los pesos de cada neurona con diversos valores, los cuales pueden ser aleatorios, en 0 ó en 0.5. Cabe destacar que cada clase es en sí un vector del mismo tamaño de las máscaras.

El proceso de aprendizaje se lleva a cabo N veces, por cada vez, se pasan todas las máscaras que contiene la imagen, y siguiendo la regla de Kohonen por cada máscara calculamos la distancia de ésta a cada clase (distancia Euclidiana, por ejemplo), la que se encuentre más cercana se le actualizan los pesos dependiendo de la regla que se considere.

Después de que se aprenda las N veces pasamos otra vez la imagen, pero ahora, no se actualizan los pesos, sino que se obtiene solamente la clase ganadora; por cada clase podemos definir un color, el cual es asignado solamente al píxel central de la máscara en la que nos encontramos.

Al final obtendremos algo así:

Inicial

Final con 5 clases

Final con 20 clases

[1] Kohonen T., Self-Organizing Maps, Tercera ed. London: Springer, 2001.

[2] Bonifacio Martín del Brío, Redes Neuronales y Sistemas Borrosos.: Alfaomega Ra-Ma, 2007.