Texturas Naturales

La idea es tratar de imitar la textura de cierto pedazo de aglomerado (una variedad de madera que une diferentes residuos y los prensan con pegamento ).
Parecido a esto:

Lo que se hace en el código es edición de imágenes con la librería de PIL para python, primero creando una imagen en blanco o tomando una imagen en blanco como referencia (en formato RGB), posteriormente se obtienen los valores de los colores de cada pixel (en RGB) y se modifican siguiendo cierto criterio, que como ya todos saben la madera tiene un patrón de líneas (semi-paralelas).

Así que lo primera idea es la de imitar este patron de líneas usando diferentes tonos de cafes/negros y amarillos para simular las lineas.

Este es el código, se usa la la libreria PIL para edición de imágenes:

import random 
from Tkinter import * 
import Image, ImageTk

negros = [(0,0,0), (139,69,19), (160,82,45) (210,105,30)] 
amarillos = [(255,215,0), (218,165,32), (184,134,11), (205,133,63)] 

im = Image.new("RGB",(350,350))
pixels = im.load()

for i in range (0, 350):
 for j in range(0, 350):
  if(i%2==0):
   pixels[i,j] = random.choice(amarillos)
  else:
   pixels[i,j] = random.choice(negros)

im.save("textura.bmp")
tk= Tk()
tkimage = ImageTk.PhotoImage(im)
label = Label(tk, image=tkimage).pack()

tk.mainloop()

Una imágen de la textura lograda:

Otra con zoom:

Aunque, tal ves puede pasar tambien como una textura de una especie de corcho o incluso tela :P.


__________________________________________________________________________________
Enlaces:
Documentación de PIL

Respuestas visuales, auditivas y táctiles

En esta entrada la idea era mostrar una especie de interacción entre el usuario y la maquina (donde se ejecuta una aplicación/juego). Como el curso esta orientado a la creación de un juego, estas interacciones se pueden obtener como respuestas por parte de la aplicación a acciones que realice el usuario, que pueden ser visuales, sonoras o hasta táctiles.

En el mundo de los videojuegos estas respuestas son imprescindibles:

• Las visuales, son las más presentes en todos los videojuegos, ya que cualquier situación, acción o cambio que el usuario realice, se vera reflejada en una respuesta visual, como por ejemplo al disparar una arma, una respuesta visual puede ser el humo o la pequeña explosión que se emite. 

• Las sonoras, son tambien muy presentes, ya casi en cualquier acciones que se realice y en la que se trate de imitar la realidad, lo mas natural es que se escuche algo, como ejemplo podemos retomar el disparo de una pistola, que al suceder esto se debe de emitir un sonido que emule la explosión de ésta o al quebrar un cristal, o incluso se puede tomar como respuesta sonora, la música de ambientación ya que se encuentra en constante cambio y depende de la situación en la que se encuentre el personaje o cierta acción que se realice.

• Las táctiles son un poco más recientes (según yo, su primera aparición fué en los controles del nintendo 64, añadiendo un aditamento), y su mayor uso es en las consolas de juegos, ya que se encuentran en los controles como pequeños motores que los hacen vibrar en diversas situaciones, como al disparar, golpear, recibir daño, etc.

Para tratar de explicar un poco mejor esto, realice una pequeña implementación usando un arduino, botones, leds, un piezo/speaker/buzzer y muchos cables :P.

La idea que se me ocurrió fue la de hacer juego de reacción (tratando de imitar un juego de unos topos que se golpean con un mazo) donde tengo 3 leds y 3 botones, los led prenden aleatoriamente y la meta es presionar el boton del led que esta encendido.

El jugador tiene 1/2 segundo para reaccionar, si el jugador atina se enciende un led de aprobación (verde) y se emite un sonido agudo, de lo contrario o si no se presiona nada se enciene un led de error (rojo) y se emite un sonido grave.

Aquí las respuestas a las acciones del jugador son visuales y auditivas, donde las visuales son en las que encienden los leds (aprobación y error)  y las sonoras son en las que se emiten los sonidos (agudos y graves).

Sin más, aquí dejo la imágen del diagrama hecho con Fritzing para las conexiones:

Aquí unas fotos del circuito real:

El código para el arduino esta muy simple, se hace uso de conexión serial, encendido y apagado de pines digitales, lecturas de pines digitales y de random para encender los leds aleatoriamente:

int led1 = 2;
int led2 = 3;
int led3 = 4;
int boton1 = 5;
int boton2 = 6;
int boton3 = 7;
int ok = 8;
int error = 9;
int bocina = 10;


void setup(){
Serial.begin(115200);

pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(ok, OUTPUT);
pinMode(bocina, OUTPUT);
pinMode(error, OUTPUT);
pinMode(boton1, INPUT);
pinMode(boton2, INPUT);
pinMode(boton3, INPUT);

}

void loop(){
   
    int led = random(2, 5);
  
    digitalWrite(led, HIGH);
    Serial.print(led-1);
    delay(500);
    
    int boton = led + 3;
    
    int estado = digitalRead(boton);
    delay(500);
    if (estado == HIGH){
      digitalWrite(ok, HIGH);
      tone(bocina, 900, 250);
      delay(500);
      Serial.print(boton-4);
      Serial.print(1);
    }
    else{
      digitalWrite(error, HIGH);
      tone(bocina, 400, 250);
      delay(500);
      Serial.print(0);
      Serial.print(0); 
    }     
  
  digitalWrite(led, LOW);
  digitalWrite(ok, LOW);
  digitalWrite(error, LOW);  
  delay(250);
}

• Al principio se establecen que pines se usaran y como se usarán, entradas o salidas.
• Ya en la parte de ejecución del programa, primero se usa random, para obtener un entero y usar este para encender cierto led.
• Ya encendido el led, se usa un delay(500) para tener oportunidad de ver al led encendido.
• Se busca que se presione el botón correspondiente, esto sumando 3 al entero que se uso para encender led y ya con este número de pin se hace la lectura con digitalRead().
• Se usa un delay(500), que equivale a 1/2 segundo para esperar a que reaccione el jugador.
• Con la lectura obtenida, se entra al if, si se presiona se enciende el led ok(verde) y la bocina emite un sonido agudo, usando la función tone, que tiene como parametros (pin, frecuencia(MHz), duración(milisegundos)), entre más alta la frecuencia mas agudo el sonido. si no se presiona sucede todo lo contrario, se enciende el led error (rojo) y se emite un sonido grave.
• Al final se apagan todos los leds encendidos, la bocina se apaga sola al terminar la duración de su sonido, se puso un pequeño delay(250) para darle un tiempo al arduino antes de que se vuelva a repetir todo el proceso.

También, como el código de arduino usa conexión serial, elabore un pequeño programa en python que usa esta comunicación serial y usa los datos recibidos para mostrar una forma de puntuación en pantalla, además de indicar cuando se acierta o falla en el juego.

import serial

s=serial.Serial(2,115200)

def main():

 marcador, total = 0, 0

 while (True):
  l = int(s.read())
  b = int(s.read())
  r = int(s.read())
  print "Led #", l, " Boton #", b

  total +=1 

  if(r == 1): 
   marcador += 1
   print "Acertaste!!"

  else:
   print "Fallaste!!"

 
  print "Tu puntuacion -->> ", marcador, "/", total

main()  

• Se usa la librería pyserial, se importa como import serial.
• Se crea un objeto tipo serial con los parametros (puerto, baudrate), se pueden usar más, pero con estos son suficientes para este propósito. el puerto es asignado por windows para el arduino es COM3 o 3, pero debido a que la librería pyserial los enumera desde 0, por eso se estableció 2, (en Ubuntu el manejo de los puertos es de manera diferente).
•  Con el objeto serial, se hacen las lecturas de la información enviada por el arduino, mediante la función read().
• Se usa un while infinito para que siempre que el arduino envíe datos este leyendo.
• Las variables, l se usa para el valor de led encendido, b para el boton presionado y r para el resultado de si se presiono o no el correcto, y se convierten todos a enteros.
• Si r arroja un 1, quiere decir que se acertó y se suma uno al puntaje.
• Al final se muestra el puntaje,en el formato de, cuantas veces que se acertó de cuantas posibles y se repite todo el proceso.

Una captura del programa de python:

Aquí dejo un video de como funciona el juego:

____________________________________________________________________________________

Enlace Útiles:

www.fritzing.org
www.arduino.cc 
http://pyserial.sourceforge.net/ 

Investigación de Usabilidad en Sistemas Inteligentes

El artículo que yo elegí, su nombre es: USABILITY OF INTELLIGENT AGENT SYSTEMS IN URBAN TRAFFIC CONTROL algo como Usabilidad de Sistemas de Agentes Inteligentes en Control de Tráfico Urbano. Es na investigación realizada por Danko A. Roozemond & Peter van der Veer del departamento de Informática de Ingeniería Civil en la Universidad de Tecnología de Delft, en Delft, Países Bajos.

El link del documento de la investigación esta aquí (en pdf e inglés).

Al principio del documento mencionan que la investigación se centra en el manejo inteligente y dinámico del tráfico de vehículos y como esto puede adaptarse y responder a las condiciones del tráfico en tiempo real. Por lo que su investigación se centra en que tan difícil (usabilidad) puede resultar la implementación de agentes inteligentes que ayuden a controlar el tráfico y la aplicabilidad de esto para mantener niveles altos de precisión y facilidad de uso de estos sistemas dinámicos para controlar satisfactoriamente el tráfico vehicular.

En pocas palabras, ellos buscan saber que tan complicado puede resultar implementar un sistema de este tipo y su grado de usabilidad si se implementara esto.

Esta parte me recordo a una pequeña práctica que realizamos en el laboratorio de sistemas adaptativos, en la que se buscaba agilizar el tráfico de vehículos mediante semáforos que cambiaban dependiendo de que tanto tráfico había en una calle, consiguiendo con esto que una calle con más tráfico que otra tuviera prioridad para desahogar el su flujo de vehículos y que fuera capaz de detectar todo esto en tiempo real y estar cambiando constantemente.

Estos tipos para su investigación buscaron recursos dentro del uso de agentes inteligentes, redes neuronales o sistemas de computo distribuido.

Hablan de que la mayoría de las personas pasa mucho de su tiempo manejando en carreteras/caminos/avenidas y que en la mayoría de los casos estos trayectos se realizan en horas donde la demanda de estos caminos o avenidas es mucha (salidas del trabajo, escuelas, etc.), por estos hechos las dependencias correspondientes (en México la SCT) se ven obligadas a construir más y más tramos de carretera, pero con el tiempo se vuelven otra vez avenidad saturadas.

Todos estos inconvenientes influyen en el desarrollo de sistemas inteligentes o IDTMIS (Dynamic Traffic Management and Information System) como ellos lo llaman (esto proviene de una investigación anterior), que trabajaran como un grupo multi-disciplinario, incorporando todos los sistemas necesarios para el control y el manejo del tráfico para solucionar esta problemática.

Se centran mucho en el desarrollo de sistemas de agentes inteligentes, mencionando que la idea es que cada agente sea autónomo y cuanto más grande sea este nivel de autonomía mas eficiente puede resultar ya que también se reduciría la intervención de personas(humanos) en los procesos de automatización y estas personas pueden ser requeridas en otros campos donde se realicen procesos más complejos y aportando ideas en procesos como tomas de decisiones o proveer asistencia técnica a estos agentes. (Ya que no se tiene previsto que un agente tenga la capacidad de "reparar" a otro.)

Esto hace que las tareas más básicas puedan realizarlas los agentes y asi convertirlas en procesos automatizados para obtener un mejor performance en estas tareas, además de que estos procesos automatizados se pueden combinar más facilmente para en un dado caso realizar otra tarea un poco más compleja y obtener como ya se dijo un buen performance.

Otro aspecto que se trata en la investigación es que el tráfico vehicular de las ciudades modernas es por mucho muy variado (autos, camionetas, bicicletas, peatones, camiones, etc), esto puede complicar las cosas al momento de tratar de que los agentes identifiquen vehiculos para realizar acciones o tomar decisiones por si solos.

Debido a esto el sistema de agentes inteligentes no solo debe de ser algo que se adapte en tiempo real, si no que ademas de esto, es necesario que el sistema tenga la capacidad de estar aprendiendo constantemente para facilitar las tareas de identificación de los agentes.

Una parte muy importante en la implementación de este tipo de sistemas es la comunicación, ya que una pequeño flujo constante de información hacia el sistema puede ayudar a que funcione correctamente, ya que si en algún momento puede ocurrir algún accidente en X lugar, esta información se envía al sistema y el sistema puede tomar la decisión de desviar el tráfico en algunas partes para agilizarlo y también poder así apoyar a los cuerpos de seguridad/rescate.

En este aspecto las redes de comunicación juegan un papel muy importante ya que debido a esto puede establecerse de manera más facil y eficiente el tráfico de la información, usando diferentes estadares internacionales para facilitar aún más las cosas.

En resumen, toda esta investigación esta centrada en la solución al gran problema del tráfico vehicular y ellos buscan la manera de ofrecer una solución diferente este problema. Hacieno uso de la tecnología con la que se cuenta actualmente y encaminandose a algo tal vez un poco mas futurista, pero que solucionaría este problema, la menos en un determinado tiempo.

En cuanto a la usabilidad de este sistema, se buscaría que los agentes cuenten con muchas capacidades automatizadas, que la intervención de los hombres sea las más mínima en estos procesos y que si en algún momento es necesario que estos agentes interactúen con usuarios comúnes (persona sin conocimientos sobre esto) sean de la manera más facil, usando interfaces muy intuitivas y buscando siempre, que estos agentes den solución a las dudas de los usuarios.
Todo esto debe de ir en constante perfeccionamiento ya que se buscaría que el sistema sea capaz de adaptarse y aprender constantemente.

____________________________________________________________________
Enlaces:

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.41.1404&rep=rep1&type=pdf