September 9 2011

Nunca subestimes…

Friday, September 9, 2011 12:25
Posted in category Otros

Never underestimate the bandwidth of a station wagon full of tapes hurtling down the highway

Nunca subestimes el ancho de banda de una furgoneta que viaja cargada de cintas (DVD’s)

 

Andrew S. Tanenbaum

September 1 2011

Failed FTP upload: 521 PROT P required

Thursday, September 1, 2011 13:21
Posted in category Administrador Sistemas

Intentando conectarme a un servidor FTP seguro mediante el comando curl recibí el siguiente mensaje de error: “PROT P required”.
Aquí podemos ver los logs del intento de conexión:

< 220 Welcome to XXXXX.
> USER usuario
< 331 Password required for usuario
> PASS YYYYY
< 230 Logged on
> PBSZ 0
< 200 PBSZ=0
> PWD
< 257 "/" is current directory.
* Entry path is '/'
> CWD IN
< 250 CWD successful. "/IN" is current directory.
> EPSV
* Connect data stream passively
< 229 Entering Extended Passive Mode (|||2191|)
*   Trying YYY.XXX.ZZZ.YYY... connected
* Connecting to YYY.XXX.ZZZ.YYY (YYY.XXX.ZZZ.YYY) port 2191
> TYPE I
< 200 Type set to I
> STOR fichero_prueba.txt
< 521 PROT P required
* Failed FTP upload: 521
* Remembering we are in dir "IN/"
* Uploaded unaligned file size (0 out of 33 bytes)
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0* 
Connection #0 to host XXXX.XXX.net left intact
 
curl: (25) Failed FTP upload: 521

Para solucionarlo hay que indicarle al comando curl que envie el comando PROT P. Esto se indica pasándole al comando curl el parámetro Q como se puede ver a continuación:

curl   -vk  -T fichero_prueba.txt  
-u cust-usuario:password ftpS://YYY.XXXX.net:PORT/ruta/ 
--ftp-pasv  
-Q "prot p"
August 21 2011

Resolver el error “invalid command-line parameter: Files” (Android SDK – AVD)

Sunday, August 21, 2011 18:12
Posted in category Otros

Hoy me he puestro a trastear con mi nuevo movil Android, y pretendía poder crear mi primera aplicación. Después de descargarme el SDK de Google para Android y configurar el Eclipse con el pluggin correspondiente para compilar y emular aplicaciones Android me he encontrado el siguiente error:

Al parecer es bastante sencillo de solucionar. Bastará con cambiar la el path del SDK de Android en las preferencias de Android de nuestro Eclipse:

por el siguiente path en Windows 7:

Si estuvieramos trabajando en otro Windows lo normal sería cambiar la ruta por “C:\Progra~1″ en lugar de “C:\Progra~2″ .

  • “C:\Program Files\…” se convierte en “C:\Progra~1\…”
  • “C:\Program Files (x86)\…” es lo mismo que “C:\Progra~2\…”
August 6 2011

Transformaciones Geométricas en OpenGL

Saturday, August 6, 2011 18:25
Posted in category OpenGL, Programación

Una vez que hemos aprendido a utilizar las primitivas de OpenGL el siguiente paso será aprender a utilizar las transformaciones geométricas que nos permitirán modificar la posición y orientación de los obejtos.

No hace falta ser un genio de las matemáticas para poder hacer uso de las funciones que OpenGL nos ofrece para realizar transformaciones geométricas, del mismo modo que podemos conducir un coche sin conocer todos los mecanismos internos. Lo que si necesitamos, es conocer los aspectos básicos que nos permitiran conocer qué cosas se pueden hacer y qué herramientas serán las mejores para conseguir nuestros propósitos.

Cuando hablamos de gráficos 3D realmente no estamos hablando de objetos en 3D, sino que estamos tratando conceptos 3D para describir cómo un objeto 3D puede representarse en un monitor 2D. A este proceso se le denomina “proyección“.

Por tanto los objetos 3D se proyectan en el plano, pero hay varias formas de “ver” esta proyeccion, la proyección en perspectiva y ortogonal. En la primera los objetos más lejanos se verían mas pequeños, que es lo que en realidad pasa, mientras que en la segunda todos los objetos se ven a la misma distancia y tienen el mismo tamaño.

La proyección es una de las transformaciones que nos permite utilizar OpenGL pero existen muchas más. Las transformaciones nos permitirán por ejemplo rotar objetos, desplazarlos o escalarlos.

Ejemplo de rotaciones de objetos sobre los ejes de coordenadas X,Y y Z.

traslacion

Ejemplo de la traslación de un objeto.

Es muy importante hacer incapié en que las transformaciones geométricas se aplican antes de que un objeto sea visualizado. Veamos algunos códigos de ejemplo OpenGL.

Traslación:

Imaginemos que queremos pintar un cubo de 10 unidades y que queremos desplazarlo 10 unidades sobre el eje X. El código sería:

// Nos trasladamos 10 unidades sobre el eje X
glTranslatef(10.0f, 0.0f, 0.0f);
//Pintamos el cubo
glutWireCube(10.0f);

Rotación:

Para rotar un objeto sobre uno de los 3 ejes de coordenadas, o sobre cualquier otro vector definido V (x,y,z), OpenGL nos permite utilizar la función:

glRotatef (GLfloat angulo, GLfloat x, GLfloat y, GLfloat z);

El ángulo de rotación es siempre un ángulo en sentido en contra de las agujas del reloj y  medido en grados.  Si por ejemplo quisieramos rotar 45 grados nuestro cubo sobre el eje x el código sería el siguiente:

// Realizamos la rotación
glRotatef(45.0f, 1.0f, 0.0f, 0.0f);
//Pintamos el cubo
glutWireCube(10.0f);

Escalado:

El escalado es una transformación que permite cambiar el tamaño de un objeto expandiendo o contrayendo todos sus vértices. La función que nos permite realizar el escalado en OpenGL es la siguiente:

glScalef (GLfloat x, GLfloat y, GLfloat z);

El escalado no tiene porqué ser uniforme, y podemos expandir por tanto un objeto más en anchura que en altura. Un ejemplo que ensancha el tamaño del cubo al doble en el eje X:

// Realizamos el escalado
glScalef( 2.0f, 1.0f, 1.0f );
//Pintamos el cubo
glutWireCube(10.0f);

Cuando se trata de aplicar una sola transformación no hay ningún problema con las funciones anteriormente comentadas, pero en el caso de que queramos realizar varias transformaciones a un objeto tendremos que entender mejor cómo las gestiona y lleva a cabo OpenGL. La idea principal es que OpenGL utiliza una pila (LIFO) para almacenar las transformaciones.

comportamiento diferente pila opengl transformaciones

En la imagen anterior vemos la diferencia entre ejecutar una traslación  primeramente y un escalado en segundo lugar, y ejecutar primero un escalado y luego una traslación:

//primer ejemplo
glScalef( 2.0f, 2.0f, 2.0f);
glTranslatef( 10.0f, 0.0f, 0.0f);
glutWireCube(4.0f);
//segundo ejemplo
glTranslatef( 10.0f, 0.0f, 0.0f);
glScalef( 2.0f, 2.0f, 2.0f);
glutWireCube(4.0f);

En el primer caso, la primera transformación que se ejecuta es la Traslación y posteriormente el Escalado, aunque en el código lo veamos al revés. ¿Cuál es la razón? La razón está en el comportamiento de la pila. Al ejecutar secuencialmente el código la primera transformación es el Escalado,  que es la primera en entrar en la pila, mientras que la Traslación entra después. La traslación está encima del Escalado y por eso se ejecutará antes.

OpenGL tiene una pila para las transformaciones geométricas y de la cámara llamada GL_MODELVIEW, y otra para las proyecciones denominada GL_PROYECTION. Para indicar sobre qué pila estamos trabajando se utiliza la función glMatrixMode(Nombre_Pila).

Si quisieramos realizar diversas transformes a diferentes objetos la situación se nos complicaría ya que las transformaciones se irían acumulando en la pila. Si se quieren aplicar distintas transformaciones a distintos objetos sería necesario poder modificar el contenido de la pila. OpenGL nos ofrece 3 funciones para manejar las pilas: glLoadIdentity(), glPushMatrix() y glPopMatrix().

matriz push pop translate

La función glLoadIdentity sustituye el contenido de la pila por la matriz de identidad.

La función glPushMatrix() realiza una copia de la matriz superior y la pone encima de la pila, de tal forma que las dos matrices superiores son iguales. De esta forma al llamara a la función glPushMatrix() se duplica la matriz superior y por tanto las siguientes transformaciones que se realizan se aplicarán sólo a la matriz superior de la pila, quedando la anterior con los valores que tenía en el momento de llamar a la función glPushMatrix().

La función glPopMatrix() elimina la matriz superior, quedando en la parte superior de la pila la matriz que estaba en el momento de llamar a la función glPushMatrix().

August 6 2011

Cómo activar la cuenta oculta del administrador en Windows Vista

Saturday, August 6, 2011 18:20
Posted in category Informática

Hace unos días me dejaron un ordenador con el “sistema operativo” Windows Vista para que le echara un vistazo ya que se había quedado inutilizado al no poder entrar con la única cuenta de usuario visible al sistema.

Para solucionarlo habilité la cuenta de usuario administrador entrando en modo a prueba de fallos y ejecutando los siguientes pasos:

1. Loguearme con la única cuenta activa (en modo a prueba de fallos me dejaba acceder)
2. Ejecutar CMD como administrador
3. Teclear: Net user administrator
4. Teclear: Net user administrator /active:yes
5. Cambiar de usuario o reiniciar
6. Acceder como administrador

Una vez que accedí como administrador ya pude crear otra cuenta de usuario.

July 31 2011

El z-buffering

Sunday, July 31, 2011 20:14
Posted in category OpenGL, Programación

“Los objetos cercanos ocultan a los más lejanos”

El z-buffering, o el buffer de profundidad es la parte de la memoria de nuestra tarjeta gráfica encargada de la visibilidad de nuestros gráficos 3D según las coordenadas de sus pixeles, con lo que se puede gestionar qué elementos de una escena renderizada son visibles y cuales permanecerán ocultos según sus posiciones en el eje Z ( distancia a cámara ).

Cuando dibujamos un objeto, la profundidad de sus pixeles se guardan en este buffer.  Si utilizamos dichos pixeles  en pantalla para dibujar otro objeto, se producirá la comparación de las profundidades de dichos pixeles. Si la profundidad  del último es mayor que la nueva (está más lejos) el pixel nuevo no se pinta, mientras que si está más cerca (la profundidad es menor), se dibuja el pixel y se guarda la nueva profundidad en el z-buffering. En definitiva lo que se hace es comparar las profundidades de ambos gráficos para representar el objeto más cercano al observador. La profundidad elegida se guardará en el z-buffering reemplazando a la anterior.

Un Ejemplo:

Nada mejor que verlo con un ejemplo. Vamos a proceder a pintar un triángulo en primer lugar y cercano a nosotros (coordenada 0 del eje Z)  y un rectángulo en segundo lugar y más alejado de nosotros (coordenada -50 en el eje Z).
Dependiendo de si hemos habilitado o no el soporte de profundidad en OpenGL los resultados pueden ser los que se ven en la siguientes imágenes:

  • Con el buffer habilitado

z-buffer-enabled

  • Con el buffer deshabilitado

z-buffer-disabled

Como podemos ver, al habilitar el buffer de profundidad, el primer objeto que veremos será el triángulo rojo, ya que se encuentra más cercano a nosotros. Al deshabilitar el buffer, el rectángulo azul, pintado más tarde y más lejano a nosotros, sobreescribe la profundidad del triángulo por lo que lo vemos visible por encima del triángulo.

Para habilitar o deshabilitar el buffer de profundidad nos tendremos que valer de las siguientes funciones:

    glEnable(GL_DEPTH_TEST);
    glDisable(GL_DEPTH_TEST);

El código utilizado para dibujar las anteriores primitivas es el siguiente:

    //dibujamos un triángulo rojo
    glColor3f(1.0f, 0.0f, 0.0f);
    glBegin(GL_TRIANGLES);
        glVertex3f(0.0f,0.0f,0.0f);
        glVertex3f(0.0f,50.0f,0.0f);
        glVertex3f(50.0f,0.0f,0.0f);
    glEnd();
 
    //dibujamos un rectángulo azul más lejano
    glColor3f(0.0f, 0.0f, 1.0f);
    glBegin(GL_QUADS);
        glVertex3f(0.0f,0.0f,-50.0f);
        glVertex3f(0.0f,50.0f,-50.0f);
        glVertex3f(20.0f,50.0f,-50.0f);
        glVertex3f(20.0f,0.0f,-50.0f);
    glEnd();

Para habilitar el uso de la función glEnable(GL_DEPTH_TEST) tendremos que haber inicializado el sistema con el Buffer de Profundidad:

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

El buffer de profundidad se puede limpiar utilizando la siguiente función:

glClear( GL_DEPTH_BUFFER_BIT );
July 30 2011

Primeros pasos con OpenGL en Windows y Code::Blocks

Saturday, July 30, 2011 18:05

OpenGL (Open Graphics Library) es una especificación estándar que define una API multilenguaje y multiplataforma para escribir aplicaciones que produzcan gráficos 2D y 3D.

En este primer capítulo os voy a hablar de cómo configurar Code::Blocks para poder trabajar con OpenGL.

CODE::BLOCKS

Para quien no lo sepa Code::Blocks es  un entorno de desarrollo integrado libre, gratuito y multiplataforma para el desarrollo de programas en lenguaje C++.

Lo primero que tendremos que hacer es bajarnos la última versión de Code::Blocks desde su página oficial: http://www.codeblocks.org y acceder a la sección Downloads:
http://www.codeblocks.org/download/binaries donde procederemos a descarganos la versión que incluye en compilador GCC y el GDB debugger de MinGW. En mi caso esta:

codeblocks-10.05mingw-setup.exe

Una vez desgargado simplemente tendremos que ejecutar el instalador. Al terminar la instalación y ejecutar  Code::Blocks tendremos que establecer el compilador por defecto, en nuestro caso utilizaremos GNU GCC como pre-determinado.

GLUT

Ya tenemos Code::Blocks instalado, pero nos falta configurar las librerias de OpenGL para empezar a utilizar esta API tan potente.

Necesitaremos GLUT, (del inglés OpenGL Utility Toolkit), que es una biblioteca de utilidades para programas OpenGL que principalmente proporciona diversas funciones de entrada/salida con el sistema operativo. Los dos objetivos de GLUT son  permitir la creación de código más portable entre diferentes sistemas operativos (GLUT es multiplataforma) y hacer OpenGL más simple.  Y dicho esto… manos a la obra:

  1. Tendremos que dirigirnos a la página web de Nate Robins: http://www.xmission.com/~nate/glut.html y descargarnos los binarios del OpenGL Utility Toolkit (GLUT).
  2. Una vez hecho esto tendremos que descomprimir el ZIP en una carpeta de nombre GLUT.
  3. Crearemos en la carpeta recién creada “GLUT” las carpetas “bin“, “include” y “lib“. Dentro de la carpeta “include” tendremos que crear también la subcarpeta “GL“.
  4.  En la carpeta “GL“,  que está dentro de “include” tendremos que copiar el archivo “glut.h
  5. En la carpeta “lib” tendremos que copiar el archivo “glut32.lib
  6. Por último tendremos que copiar en la “bin” el archivo “glut32.dll

Creando un proyecto en CODE::BLOCKS utilizando GLUT

  • Ejecutar CodeBlocks
  • Crear un nuevo Proyecto

  • Seleccionar “GLUT Project”

  • Especificar la carpeta donde descargamos anteriormente las librerías de GLUT

  • Seleccionar el compilador “GNU GCCCompiler” y marcar las configuraciones “Debug” y “Release”.
  • Finalmente, presionar “Finish
  • Agregar: #include <windows.h> como primera línea de código y presionar F9 (Build and run)
  • Veremos en funcionamiento nuestro primer programa utilizando las librerias de OpenGL

July 25 2011

Cómo ha cambiado la vida en estos últimos 10 años

Monday, July 25, 2011 17:22
Posted in category Humor Geek

Visto aquí

July 24 2011

Obtener el último ID de un INSERT en Java

Sunday, July 24, 2011 10:07
Posted in category Programación
public int ejecuta_query(String Query) {  
 
  PreparedStatement pstmt;  
  int key = 0;  
 
 
  try {  
 	pstmt = conn.prepareStatement(Query, 
                                Statement.RETURN_GENERATED_KEYS);  
 
 	pstmt.executeUpdate();  
 	ResultSet keys = pstmt.getGeneratedKeys();  
 
 	keys.next();  
 	key = keys.getInt(1);  
 	keys.close();  
 	pstmt.close();  
 	conn.close();  
      } catch (Exception e) { e.printStackTrace(); }  
 
 	return key;  
 }
July 23 2011

Optimizando las landings pages de los bares

Saturday, July 23, 2011 22:47
Posted in category Humor Geek, Internet, SEO

En nuestra empresa estamos cansados de hacer “landing pages” que para quien no lo sepa es una página a la cual accede un usuario después de haber hecho click en algún banner, con el objetivo de vender un producto utilizando para ello un diseño atractivo, claro de entender y estrucuturado que consiga captar un nuevo cliente. (Espero que los puristas me perdonen si la definición no es del todo correcta).

Hoy damupi me ha pasado una idea original en la cual se puntuan lo que serían las “landings pages de los bares”, es decir las pizarras de los bares. En este ranking se repasan los pros y los contras de cada uno de los diseños. Sin duda una idea original y efectiva para transmitir conocimientos de marketing.

El siguiente diseño es uno de los que mayores notas obtuvo. Pero para llegar al 10 le hubiera faltado generar deseo de consumo:

El diseño ganador sería el siguiente:


Página 7 de 64« Inicio...56789...Fin »