Actividad 3: Encontrar líneas Diagonales

Para esta entrada, lo que se encargó fue implementar la detección de líneas diagonales en el mismo código de detectar líneas horizontales y verticales.

Para poder lograrlo lo que se hizo fue encontrar cualquier gx o gy que fuera diferente a cero, con esto estamos excluyendo todas las líneas horizontales y verticales.

Código:

	def hough(image):
	dict_linea = dict()
	continuidad = dict()
	prewittx = [[-1.0, 0.0, 1.0], [-1.0, 0.0, 1.0], [-1.0, 0.0, 1.0]]
	prewitty = [[1.0, 1.0, 1.0], [0.0, 0.0, 0.0], [-1.0, -1.0, -1.0]]
	sobbelx = [[-1.0, 0.0, 1.0], [-2.0, 0.0, 2.0], [-1.0, 0.0, 1.0]]
	sobbely = [[1.0, 2.0, 1.0], [0.0, 0.0, 0.0], [-1.0, -2.0, -1.0]]
	imgX = convolusion(image, sobbelx)
	imgY = convolusion(image, sobbely)
	w, h = image.size
	for i in range(w):
	for j in range(h):
	gx = imgX[i,j][0]
	gy = imgY[i,j][0]
	if(gx == 0 or gy == 0):
	theta = 0
	else:
	theta = abs(math.degrees(math.atan(gy/gx)))
	rho = (i*math.cos(theta)) + (j*math.sin(theta))
	dict_linea[i,j] = (theta, rho)
	continuidad[(theta, rho)] = 1
	pixel = image.load()
	w, h = image.size
	for i in range(w):
	for j in range(h):
	if dict_linea[i, j] in continuidad:
	if (dict_linea[i,j][0] > 0 and dict_linea[i, j][0] < 90) or (dict_linea[i, j][0] > 90 and
	dict_linea[i, j][0] < 180) or (dict_linea[i,j][0] > 180 and dict_linea[i, j][0] < 270) or (dict_linea[i,j][0] > 270 and dict_linea[i, j][0] < 360):
	pixel[i,j] = (255, 0, 0)
	image.save('lineasDiagonales.png')
	return image

view raw gistfile1.py hosted with ❤ by GitHub

Resultados:

Notas:
Ahora lo que me interesaría lograr es encontrar la continuidad de una línea y que me dijera cuantas hay, para esto mi idea es hacer un dfs de los bordes de la formas e ir comparando el pixel con su ángulo anterior con una breve diferencia, y al cabo de tener un cambio brusco la continuidad termina.

Medidas QoS

Qos lo encontranos normalmentente en redes de telecomunicaciones y ésto se refiere a la calidad de servicio para garantizar la información en un tiempo dado.

Problemas comunes que se presentan en la calidad de servicio y algunos términos que se manejan:

• Disponibilidad: Tiempo mínimo que el operador asegura que la red estará de estacionamiento.
• Ancho de Banda: Indica el ancho de banda mínimo que el operador garantiza al usuario dentro de su red. Nosotros lo vemos como la cantidad de subida y descarga que disponemos de un servicio.
• Perdida de Paquetes: Es la imposibilidad de enviar paquetes a su destino, manteniéndolo en el buffer.
• Round Trip Delay: El retardo de ida y vuelta de los paquetes en los distintos nodos de la red.
• Jitter: Es llegada de una secuencia de paquetes con retardos dispares para cada uno de ellos, lo que perjudica gravemente a las comunicaciones ordenadas, como las secuencias de audio, por ejemplo.
• Entrega de paquetes fuera de orden: Es causado por el rutado de distintos caminos de los paquetes de una secuencia, que sólo puede ser corregido por determinados protocolos de transmisión, éste problema es muy común o lo vemos muy seguido en la transferencia de archivos.
• Errores:  Es lo que provocan la corrupción de los datos o la combinación errónea de paquetes.

Categorias de QoS:

• Tiempo
• Latencia
• Retraso
• Tiempo de recuperación
• Garantía
• Precisión
• Precisión de direccionamiento
• Tasa de error
• Integridad
• Robusteza
• Confianza mantenibilidad
• Resistencia supervivencia
• Contabilidad
• Costos
• Auditibilidad
• Manejabilidad
• Monitorizabilidad
• Control
• Seguridad
• Autenticación
• Confidencialidad
• Seguridad del tráfico de flujo

Para poder tener una buena comunicación se menciona que de preferencia se debe de contener:

• Jitter bajo
• Latencia baja
• Buen rendimiento en grandes redes y gran capacidad de conexiones
• Baja redundancia de bits de cabecera por paquete
• Baja redundancia de procesamiento por paquete dentro de la red y del sistema final

Aplicado
Relacionado a la entrada de clase lo que hice fue saber cuál es el tiempo de demóra del envio de paquetes en el caso investigado de intercable y las quedadas de google.

Para obtenerlo lo que se hizo fue emplear la herramienta de wireshark, sacar los paquetes enviados y transmitidos en la sesión para después filtrarlos, una vez hecho sacar la diferencia de demóra entre el envio y recepción de paquetes.

Referencia:

http://www.dte.us.es/personal/mcromero/masredes/docs/SMARD.0910.qos.pdf

http://www.slideshare.net/mariaaleja44/calidad-de-servicio-qos-en-internet-presentacion#btnNext

http://es.wikipedia.org/wiki/Calidad_de_servicio

Tarea 3: QoS Experiemento

Para esta entrada, lo que veremos será hacer un prueba de la calidad de servicio aplicado con Intercable y las video llamadas de google (hangout).

Para hacer la prueba se implemento wireshark para hacer el sniffing de los paquetes, una vez teniéndolos, filtrarlos y obtener los paquetes que buscamos y así procesar los datos como la demóra, tamaño de éstos, perdida, entre otros.

Proceso:
Con wireshark se hizo el sniffing y se pasó a csv para filtrarlo. Para filtrar lo que se hizo fue tomar la ip de origen, la ip de destino y el protocolo a usarse, en mi caso fue:

• ip: 192.168.1.98
• ip2: 74.125.1.127
• protocolo: UDP

Código que se empleo para el filtrado:

	import csv
	def readDocument(fileName, ip, ip2, protocol):
	reader = csv.reader(open(fileName, 'rb'))
	'''
	fila[0]: No
	fila[1]: Time
	fila[2]: Source
	fila[3]: Destination
	fila[4]: Protocol
	fila[5]: Length
	fila[6]: Info
	'''
	n = 1
	start = 0.0
	agrupar = []
	for index, fila in enumerate(reader):
	if(index > 0 and fila[4] == protocol): #evitamos la primera linea y leemos que sea protocolo udp
	if(fila[2] == ip or fila[2] == ip2 or fila[3] == ip or fila[3] == ip2): #filtramos unicamente las ip proporcionadas
	#tiempo
	end = float(fila[1])
	tiempo = end - start
	#print tiempo
	start = end
	agrupar.append(int(fila[5]))
	n += 1
	lista_T = total2(agrupar)
	for i, j in lista_T:
	print i, j
	def total(lista):
	nl = []
	for i in range(1, max(lista)):
	nl.append((i, lista.count(i)))
	return nl
	def main():
	readDocument('pruebaHangout', '192.168.1.98', '74.125.1.127', 'UDP')
	main()

view raw gistfile1.py hosted with ❤ by GitHub

Plot

	set yrange[0.0:0.06]
	plot 'demoraTPaquete.txt' with lines, 'demoraTPaquete.txt' smooth bezier with lines

view raw gistfile1.txt hosted with ❤ by GitHub

Una vez obtenido, se sacó la cantidad de paquetes enviados y recibidos respecto al tamaño.

El tiempo de demora entre los paquetes enviados y recibidos.

Paquetes perdidos:

Alternativa:
Otra de las alternativas donde podemos filtrar y es más fácil su uso es la herramienta de estadísticas de parte de wireshark.

[la frecuencia de transferencia de los archivos udp]

[tiempo que tarda en responder al request]

Conclusiones:
Donde podemos concluir que la mayoría de los paquetes enviados son entre 20 y 200 bytes, la demora de transferencia es muy variable y no se comporta del todo bien, como se muestra en la figura dos. ya que la primera tiene un pico y luego se comporta igual, para nuevamente tener picos.
La perdida de paquetes es mínima 8 paquetes perdidos de un total de 18296

Lab 4: Sugerencias sobre estudio de Campo

1. Automóvil seguro
• El proyecto se me hace interesante, ya que en cierto punto se asemeja al proyecto que desarrollaré, podría mencionar que veo un poco vaga con el desarrollo del proyecto si es más a la seguridad del automóvil o más de acciones predefinidas como localización del automóvil, trazado de rutas, entre otras.
2. Eye tracker
• El sistema o el proyecto se ve muy interesante, ya observando es un problema que pueden solucionar y pensando en otro uso interesante que se podría dar, sería la implementación en smartphones y tabletas.
3. Oficina personalizada
• El sistema es interesante, ya que por lo visto la idea es más aplicada en casas, pero no en oficinas, esto sería muy útil y una empresa si buscaría implementarlo.
• Un componente que podrían tomar en cuenta para el desarrollo son los xbee, ya que es un módulo que facilita la comunicación entre el arduino u otro componente electrónico y hacia otros módulos. El desarrollo de una aplicación para el historial, ya que una empresa busca saber que fue lo que se hizo entorno a ésto o las acciones tomadas.
4. Brazalete localizador
• Para éste proyecto me gustaría ver o tener la opción de usar un dispositivo móvil en lugar de un brazalete, ya que con éste podría simplificar los componentes de hardware y ayudando al desarrollo de éste.
• El uso del brazalete estaría bien identificar si se podría emplear para uso semi-rudo, como contacto de agua, algunos goles, entre otros.
5. Galería Inteligente
• Para el desarrollo del sistema recomendaría la opción del uso de qrcode, ya que mencionan del uso del rfid, pero la desventaja que veo es que la mayoría dispositivos móviles no emplean ésta tecnología y más si se busca emplear en museos públicos, a contrario del qrcode, sería procesar la imagen y redireccionarlo o tomar la información que éste genero.
6. Cama inteligente
• La idea es muy interesante y por lo tanto me sería muy útil, que estaría dispuesto a estar en las pruebas. Podría mencionar tener como una motivación para el usuario el empleo de gamification, ya que por decir, obtener una medalla(logro) o saber que se cumplio la meta propuesta, satisface al usuario.
7. Casa inteligente
• Un componente que podrían tomar encuenta para el desarrollo son los xbee, ya que es un módulo que facilita la comunicación entre el arduino u otro comonente electrónico y hacia otros módulos.
8. Garage inteligente
• El proyecto se me hace interesante, lo que me da curiosidad es lo relacionado con seguridad, de en sí especificar bien como se abrirá el garage y los web services que interactuarán con el. Los puntos a favor de ésto es que mencionan el identificar si alguien sospechoso pasa por el garage.

Tarea 3: Detección de Líneas

Para esta semana se nos encargó detectar las líneas verticales y horizontales que tiene o pudiera tener una imagen.

Para poder realizar detectar las líneas antes que nada la imagen la tuvimos que haber pasado en escala de grises, binarizada, para después aplicar la convolución y  finalmente la transformada de hough.

Una vez llegado a convolución (en mi caso apliqué las máscaras de prewitt en x & y) nosotros tendremos dos arreglos uno que son los bordes de la imagen en x y otro en y, una vez obtenido esto (gradientes horizontales y verticales) calcularemos para después obtener el ángulo de los pixeles.

Donde las fórmulas aplicadas para obtener del ángulo son theta y rho:

[http://elisa.dyndns-web.com/~elisa/teaching/comp/vision/lineas.pdf]

Donde p es rho y este nos servirá para hacer un matriz y poner las líneas que se detectan en el ángulo.

Código:

A continuación les dejo el código, pueden checar en las entrada anteriores para hacer la escala de grises, pasarla a binario y tener la convolusion.

	def hough(image):
	prewittx = [[-1.0, 0.0, 1.0], [-1.0, 0.0, 1.0], [-1.0, 0.0, 1.0]]
	prewitty = [[1.0, 1.0, 1.0], [0.0, 0.0, 0.0], [-1.0, -1.0, -1.0]]
	imgX = convolusion(image, prewittx)
	imgY = convolusion(image, prewitty)
	dict_linea = dict()
	continuidad = dict()
	w, h = image.size
	for i in range(w):
	for j in range(h):
	gx = imgX[i,j][0]
	gy = imgY[i,j][0]
	if (gx < -1 or gx > 1 or gy < -1 or gy > 1):
	#if (gx > 1 or gy > 1):
	try:
	theta = int(math.degrees( math.atan(gy/gx)))
	rho = int((i*math.cos(theta)) + (j*math.sin(theta)))
	except:
	theta = 0.0
	rho = 0.0
	dict_linea[i,j] = (theta, rho)
	continuidad[(theta, rho)] = 1
	else:
	dict_linea[i, j] = None
	continuidad[(theta, rho)] = None
	pixel = image.load()
	w, h = image.size
	for i in range(w):
	for j in range(h):
	if dict_linea[i, j] in continuidad:
	pixel[i,j] = (255, 0, 0)
	image.save('lineasImage.png')
	return image

view raw gistfile1.py hosted with ❤ by GitHub

Resultados:

Notas:
Se podría experimentar con el código un poco aplicando diferentes máscaras y viendo que diferentes resultados nos pudiera dar, al igual de tratar de obtener las líneas sin pasar necesariamente de la binarización, escala de grises y los límites de gx & gy que nos pudiera dar cuáles son las líneas continuas.

Referencias:
http://es.wikipedia.org/wiki/Transformada_de_Hough
http://elisa.dyndns-web.com/~elisa/teaching/comp/vision/lineas.pdf
http://www.slideshare.net/omarspp/segmentacin-de-imagen
http://dmi.uib.es/~aortiz/4730-tema8.pdf
http://alojamientos.us.es/gtocoma/pid/tema4.pdf

Tarea 2: String Matching

Para esta entrada, lo que se buscó fue hacer una simulación empleando métodos de búsquedas por palabras y representarlas con gnuplot para ver como se comportaban en torno a su tiempo.

Los métodos más comunes de búsqueda por palabra son:

• Knuth Morris Pratt
• Boyer Moore

Boyer Moore

Boyer moore consiste en realizar un escaneo de derecha a izquiera, moverse en dirección hacia la izquierda hasta que se produsca un error, si el primer elemento a comparar es errónea se realiza un salto respecto a su tabla de salto, de lo contrario al pasar el primer elemento de izquierda a derecha, esta se cambia y se continua de derecha a izquierda empezando con el último elemento del patrón, éste algoritmo es considerado como uno de los más eficaces para búsquedas de palabras

[http://es.wikipedia.org/wiki/Algoritmo_de_b%C3%BAsqueda_de_cadenas_Boyer-Moore]

Knuth Morris Pratt
Este algoritmo trata de localizar la posición de comienzo de un string dentro de otra. Obteniendo antes una tabla de fallos que sirve para hacer saltos entre el string cuando se encuentra un fallo. A continuación se explica la forma en la que se trabaja con éste método

"Supongamos una tabla 'F' ya precalculada, y supongamos que la cadena a buscar esté contenida en el array 'P()', y la cadena donde buscamos esté contenida en un array 'T()'. Entonces ambas cadenas comienzan a compararse usando un puntero de avance para la cadena a buscar, si ocurre un fallo en vez de volver a la posición siguiente a la primera coincidencia, se salta hacia donde sobre la tabla, indica el puntero actual de avance de la tabla. El array 'T' utiliza un puntero de avance absoluto que considera donde se compara el primer carácter de ambas cadenas, y utiliza como un puntero relativo (sumado al absoluto) el que utiliza para su recorrido el array 'P'."

Para poder realizar éste método se baso en el psudocódigo que proporciona wikipedia, en la cual, lo contiene lo anterior mencionado.

[http://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm]

[http://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm]

Código
Para tener la simulación al principio lo que se hizo fueron unas pruebas donde se tenían el texto y el paterno que había preestablecido, pero para tener diferentes resultados se hizo una función donde que se generaba palabras aleatorias dependiendo de un tamaño dado del paterno y del texto. Para así correrlo en un bash donde se metería en un bucle para generar diferentes resultados.

	def knuth_morris_pratt(paterno, texto):
	m = 0
	i = 0
	intentos = 0
	T = tabla_knuth_morris_pratt(paterno)
	index_match = list()
	start = time.time()
	while m + i < len(texto):
	if paterno[i] == texto[m + i]:
	intentos += 1
	if i == len(paterno) - 1:
	index_match.append(m)
	i += 1
	else:
	m = m + i - T[i]
	if T[i] > -1:
	i = T[i]
	else:
	i = 0
	return index_match, intentos
	def tabla_knuth_morris_pratt(patterno):
	T = list()
	for i in range(len(paterno)):
	T.append(0)
	T[0] = -1
	T[1] = 0
	pos = 2
	cnd = 0
	while pos < len(paterno):
	if paterno[pos-1] == paterno[cnd]:
	cnd += 1
	T[pos] = cnd
	pos += 1
	elif cnd > 0:
	cnd = T[cnd]
	else:
	T[pos] = 0
	pos += 1
	return T

view raw gistfile1.py hosted with ❤ by GitHub

	def generarPalabra(len_p):
	palabra = ''
	while len(palabra) < len_p:
	palabra += chr(randrange(65, 91)).lower()
	return palabra

view raw gistfile1.py hosted with ❤ by GitHub

br />

	def naive(texto, patron):
	i_word = list()
	cont_Totales = 0
	for i, char in enumerate(texto): #obtenemos el indice y su elemento
	cont_Totales += 1 #contador de exitos que tendremos
	letraFormada = list()
	n = 0
	if char == patron[n]:
	i_next = i
	while n < len(patron):
	letraFormada.append(texto[i_next])
	i_next += 1
	n += 1
	if patron == "".join(letraFormada):
	i_word.append(i)
	return i_word, cont_Totales

view raw gistfile1.py hosted with ❤ by GitHub

Bash

	#!/bin/bash
	for pattern in {2..10}; do
	for text in {15..50}; do
	corrida=`python flujo.py $pattern $text`
	echo $corrida >> resultados1.txt
	done
	done
	for pattern in {2..10}; do
	for text in {15..50}; do
	corrida=`python flujo.py $pattern $text`
	echo $corrida >> resultados2.txt
	done
	done
	gnuplot grafica.plot

view raw gistfile1.txt hosted with ❤ by GitHub

Resultados:

Una vez generados los archivos lo que se hizo fue plotearlo con gnuplot obteniendo los siguientes resultados:

Donde podemos comentar que con el metodo de naive su tiempo va creciendo al depender de las cantidades de palabras que contenga el texto y el paterno a diferencia con el método Knuth Morris Pratt que se va comportando igual y resaltando que la cantidad de éxitos es mayor cuando el paterno su tamaño es pequeño.

Referencias:

http://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm

http://www-igm.univ-mlv.fr/~lecroq/string/examples/exp14.html

http://es.wikipedia.org/wiki/Algoritmo_de_b%C3%BAsqueda_de_cadenas_Boyer-Moore

Actividad 3: Mapeo de Redes

Para esta entrada se nos encargo hacer el mapeo de redes wifi que pudiera detectar nuestra tarjeta de red. Para este caso lo que hice fue mapear las redes que se encontraban alrededor de mi casa.

Metodo de Captura

Para poder obtener las posiciones de la redes wifi, lo que se hace es identificar por así decirlo, la potencia o fuerza en la cual obtenemos la señal de la red, una vez teniendo esto podemos darnos una idea de que tan lejana esta, así que lo aplicado más concretamente es tomar diferentes muestras en diferentes posiciones y una vez teniéndolas hacer una triangulación con los datos obtenidos y poder obtener la posición.

RSSI

Antes que nada hay que explicar que es el RSSI, que como al principio se mencionó es el término que se usa para identificar la fuerza de señal de recepción y nosotros la tomamos como el nivel de potencia que recibimos de una red, entre más pequeña sea éste número su señal será baja, por lo tal no tendrá buena recepción o batallará para conectarse.

Aplicado

En mi caso empleo el comando airport de OS X, que te da la información de determinadas redes, entre otros aspectos.

[comandos de airport]

Donde el comando a usar sera -s, que escanea las redes que encuentra la tarjeta de red y te da el listado de ellas con el RSSI, su canal y el tipo de seguridad que emplea.

[listado de redes]

Una vez ontenida lo que se hizo para hacerla más exacto fue sacar el listado de las redes en diferentes posiciones de la casa, para así hacer un tipo de triangulación de principiante y poner en el mapa las redes que capturaba.

Código:

	<!doctype html>
	<html>
	<head>
	<meta name="viewport" content="initial-scale=1.0, user-scalable=no" />
	<meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
	<title>Mapa de redes wi-fi</title>
	<style>
	html, body {
	height: 100%;
	margin: 0;
	padding: 0;
	}
	#mapa {
	height: 600px;
	width: 800px;
	}
	@media print {
	html, body {
	height: auto;
	}
	}
	</style>
	<script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=false"></script>
	<script type="text/javascript">
	var m;
	function init() {
	m = new google.maps.Map(document.getElementById("mapa"));
	m.setZoom(19);
	m.setMapTypeId(google.maps.MapTypeId.HYBRID);
	var x = 25.738999721052853
	var y = -100.31557470560074
	var pos = new google.maps.LatLng(x, y);
	m.setCenter(pos);
	var conf = {
	strokeColor: '#FF0000',
	strokeOpacity: 0.8,
	strokeWeight: 2,
	fillColor: '#FF0000',
	fillOpacity: 0.35,
	map: m,
	label: "mapa",
	center: pos,
	radius: 1
	};
	c1 = new google.maps.Circle(conf);
	/*25.738895829369003,-100.31558811664581
	25.73889341328227,-100.3157302737236
	25.739031130148692,-100.31568735837936
	25.738970728033927,-100.31549423933029
	25.738907909802023,-100.31557470560074
	25.73921475238901,-100.31557470560074
	25.73891999023382,-100.31550765037537
	25.739050458818916,-100.3155666589737
	*/
	var conf2 = {
	strokeColor: "#FF00FF",
	strokeOpacity: 0.8,
	strokeWeight: 2,
	fillColor: "#FF00FF",
	fillOpacity: 0.35,
	map: m,
	center: new google.maps.LatLng(25.738895829369003,-100.31558811664581),
	radius: 9
	}; //Rojo
	c2 = new google.maps.Circle(conf2);
	var conf3 = {
	strokeColor: "#2E8B57",
	strokeOpacity: 0.8,
	strokeWeight: 3,
	fillColor: "#2E8B57",
	fillOpacity: 0.35,
	map: m,
	center: new google.maps.LatLng(25.73889341328227,-100.3157302737236),
	radius: 15
	}; //Verde
	c3 = new google.maps.Circle(conf3);
	var conf4 = {
	strokeColor: "#1E90FF",
	strokeOpacity: 0.8,
	strokeWeight: 3,
	fillColor: "#1E90FF",
	fillOpacity: 0.35,
	map: m,
	center: new google.maps.LatLng(25.739031130148692,-100.31568735837936),
	radius: 8
	}; //Azul
	c4 = new google.maps.Circle(conf4);
	var conf5 = {
	strokeColor: "black",
	strokeOpacity: 0.8,
	strokeWeight: 3,
	fillColor: "black",
	fillOpacity: 0.35,
	map: m,
	center: new google.maps.LatLng(25.738970728033927,-100.31549423933029),
	radius: 13
	};
	c5 = new google.maps.Circle(conf5);
	var conf6 = {
	strokeColor: "#FF7F50",
	strokeOpacity: 0.8,
	strokeWeight: 3,
	fillColor: "#FF7F50",
	fillOpacity: 0.35,
	map: m,
	center: new google.maps.LatLng(25.738907909802023,-100.31557470560074),
	radius: 7
	}; //Naranja
	c6 = new google.maps.Circle(conf6);
	var conf7 = {
	strokeColor: "yellow",
	strokeOpacity: 0.8,
	strokeWeight: 3,
	fillColor: "yellow",
	fillOpacity: 0.35,
	map: m,
	center: new google.maps.LatLng( 25.73921475238901,-100.31557470560074),
	radius: 15
	};
	c7 = new google.maps.Circle(conf7);
	var conf8 = {
	strokeColor: "white",
	strokeOpacity: 0.8,
	strokeWeight: 3,
	fillColor: "white",
	fillOpacity: 0.35,
	map: m,
	center: new google.maps.LatLng(25.73891999023382,-100.31550765037537),
	radius: 12
	};
	c8 = new google.maps.Circle(conf8);
	var conf9 = {
	strokeColor: "gray",
	strokeOpacity: 0.8,
	strokeWeight: 3,
	fillColor: "gray",
	fillOpacity: 0.35,
	map: m,
	center: new google.maps.LatLng(25.739050458818916,-100.3155666589737),
	radius: 12
	};
	c9 = new google.maps.Circle(conf9);
	google.maps.event.addListener(c2, "click", function(event) { alert("INFINITUM");
	});
	}
	</script>
	</head>
	<body onload="init()">
	<div id="mapa" width="200" height="200"></div>
	</body>
	</html>

view raw gistfile1.html hosted with ❤ by GitHub

Resultados:

[Como se puede ver en la imagen, se tienen las diferentes redes que se encuentran en mi casa, donde el circulo es el radio de señal de potencia que tiene la red]

Otras Herramientas:
Podemos encontrar otras herramientas donde nos ayuden a determinar la posición de alguna red como netspot y Ekahau HeatMapper, la cuál indica los lugares por así decirlo en una casa donde mejor se recibe una señal.

Referencias:

http://macs.about.com/od/LionTipsNtricks/qt/Os-X-Lion-Wi-Fi-Diagnostics.htm
http://systemadmin.es/2011/07/como-ver-los-ap-visibles-y-su-mac-en-windows-linux-y-macos-x

Actividad 3: Diseño Conceptual

El diseño conceptual, nos ayuda y nos facilita a tomar por así decirlo las palabras o recursos principales que integren una idea, para después llevar a cabo un prototipo que satisfacerá la demanda o cumplirá los requisitos establecidos.

En el diseño conceptual se puede emplear diferentes métodos, pero en mi caso mencionaré algunas que podría tomar en cuenta para el desarrollo de mi proyecto.

Metodos

1. Modelo Entidad Relación:

Esta es una técnica de análisis basada en la identificación de las entidades y de las relaciones que se dan entre ellas en la parte de realidad que pretendemos modelar.
Nosotros, podemos identificar:

• Entidades: Objetos, reales o abstractos, distinguibles de otros objetos.
• Propiedades: Propiedades asociadas a un conjunto de entidades.
• Relaciones: Conexiones semánticas entre conjuntos de entidades.

Aplicado al Proyecto:
Aplicado al proyecto podemos decir que mis entidades es el carro, el dispositivo móvil, sus propiedades El tipo de carro, número de puertas, velocidad máxima, el tipo de celular y SO, entre otros y las relaciones que es como interactúa el dispositivo móvil con el carro en éste caso para abrir la puerta, el traza de rutas, etc.

1. Prototipado:

El método prototipado consiste en realizar un diseño de baja fidelidad, un mockup o una simple imagen, dependiendo del caso, donde se vea o se entienda como estará conformada la idea, en éstos casos, el diseño de baja fidelidad puede ser muy general como el mostrar sus elementos principales y cuál será la relación de estos.

Aplicado al Proyecto:

[https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh02MXRX62apCv6lnl4H1tRszMdEMyywwuYcULiEKDY9jHOYaeS3-OUw8J9l86Ff9H-ZedF3-aoEQI1vO-hKVhJEuKDnmwGSLEs1eCT4a-Fo3ExjDI5Yhanhyphenhyphen-2J2mJR9JiF49fLM5-aFA/s1600/nfc.PNG]

1. Escenarios:

El método de escenario, permite identificar el contexto o las diferentes formas en las que  se lleva a cabo la idea o las acciones que se llevan a cabo.

Aplicado al proyecto:
Dispositivo móvil interacción automóvil: Los casos que se tienen es abrir el carro con el smartphone, donde al mismo tiempo se identifica al usuario, para realizar determinadas acciones que el usuario haya pre-establecido como la reproducción de canciones, el trazado de rutas, noticias de tráfico o clima, entre otras.

1. Perfiles de Usuario:

Los perfiles de usuario nos ayudan y nos facilitan a la identificación de los finales usuarios que tendrá la idea o el sistema.

Aplicado al proyecto: En mi caso identifiqué a los usuarios como todo aquel que sea poseedor o interactué con un automóvil y un smartphone.

1. Método de Observación:

El metódo de observación, como su nombre lo indica es observar al usuario interactuando con el medio, este método es muy usado al momento de hacer las pruebas de usabilidad, ya que identifican rápidamente por lado del investigador los posibles requisitos del sistema.

Aplicado al proyecto:
En mi caso me tomé la tarea de observar a vecinos, amigos y personas en espacios públicos de como era la interacción con el automóvil, concluyendo que interactuaban con el dispostivo móvil al estar haciendo una llamada o leyendo algún mensaje, se les olvida donde dejaron el carro, en ocasiones olvidando en que bolsillo pusieron las llaves y demorando en poner o seleccionar alguna lista de reproducción.

Referencias:
http://es.scribd.com/doc/6842770/Diseno-conceptual
https://docs.google.com/viewer?a=v&q=cache:_A7GC7iFB8EJ:elvex.ugr.es/idbis/db/docs/design/3-conceptual.pdf+&hl=es&gl=mx&pid=bl&srcid=ADGEESjkl0VS9uWXvoV5bahwfTZ1IU-rJsL0ASeTVH4_zEwPoXoRsdxz7XnqwHYui64kPkN92VSgw1PR3hiXMo-_wxsFn1Bo-m2pSo-S5qIAfko2Imolkm585d0SYCQkqaXG_TLTXhB7&sig=AHIEtbRDMJappw6BrZiRiDLBmkjKG3duHA
http://www.unalmed.edu.co/~mstabare/diseno_conceptual.htm

Tarea 3: Experimento de Monitoreo WiFi

En esta entrada, haremos un pequeño experimento en la red WiFi y sus dispositivos conectados, haciendo sniffing, la finalidad del experimento será saber las páginas que se visita y el contenido que se obtiene, buscando principalmente imagen.

[http://team-android.com/wp-content/uploads/2011/03/Hacker-Cat_397.jpg]

Sniffing
El oir la palabra sniffing se nos puede hacer algo raro si no estamos familiarizados con redes de telecomunicaciones o temas relacionados de redes. Pero ya sin tantos rodeos, podemos decir que el sniffing es la técnica por la cual podemos escuchar todo lo que circula en una red.

Funcionamiento

[http://www.multiserviciosva.com/wp-content/uploads/2010/10/conexion1.jpg]

En una red local, se tiene un modem donde es el medio que se conectan los computadores y donde sale la información hacia la internet y como se mencionó los computadores, que son los dispositivos que hacen las peticiones.
En la red toda la información que es mandada viaja en forma de paquetes y ésta es recibida por el modem, donde la manda a su destino, para después recibirla y mandar a su origen.

[http://electiva3seguridad.wikispaces.com/file/view/SNIFFER1.jpg/136995931/408x323/SNIFFER1.jpg]

Al momento de hacer sniffing en una red, toda la información que viaje en ella, pasa por nuestro computador o de un tercero, siempre y cuando se haya puesto en modo monitor la tarjeta de red, para así ir capturando todos lo paquetes salientes y entrantes.
Una vez que se tienen los paquetes, se pueden desempaquetar y ver su contenido (origen, destino, tamaño y su información, todo dependiendo del protocolo empleado), para hacer uso de éste. 

Herramienta & Instalación

Para poder hacer sniffing, se puede emplear diferentes herramientas como Ettercap, Wireshark y Cain & Abel, en éste caso se empleará Wireshark, donde ya tengo un tutorial de instalación en ubuntu y sus primeros pasos.

Proceso

Como se mencionó, para esta auditoría será saber los links que se visitan, al igual que su contenido donde nos enfocaremos en la imagenes.

Páginas Visitadas

Wireshark es una herramienta muy potente donde nos da muchas opciones para el manipulado de la información, filtrado, decodificaciones, entre otros (tomaré en cuenta que el lector visitó el link de primeros pasos, donde ya se vió de habilitar para el escuchar paquetes).
Para poder saber las páginas que se visitan nos podemos ir en Edit/Preferences/Name Resolution y activar el nombre de la Red, para así cuando empecemos nuestra auditoría nos pondrá la dirección en lugar de la ip de Origen.

Contenido

Wireshark, nos da también la facilidad de ver éste contenido y el filtrado de ello.

[paquetes capturados]

[filtrado de paquetes]

[Contenido del Paquete]

[Paquete puro donde en rojo es la petición y en azul lo recibido]

Imagenes:
Como se manejaba al principio, lo que nosotro buscaremos es el ver las imagenes que se enviaron, por lo tanto, Wireshark nos da la opción de decodificarlas, ya que si nosotros queremos verlas, nos aparecerá en formato binario, así que guardaremos en Archivo/Guardar, para despues ir nuevamente en Archivo/Exportar Objetos/HTTP y nos saldrá la siguiente imagen, para despues guardar.

Si en los paquetes capturados contiene alguna imagen, esta nos aparecera en el folder que previamente generamos para guardar el contenido, en mi caso estaba googleando a Emma Watson y me guardo la siguiente imagen:

Conclusiones

Con éste experimento, me ayudó a reflexionar, sobre la información que viaja a través de una red, ya que en la mayoría de los veces viaja en texto plano y es fácil leerla con herramientas de éste tipo, en éste caso se manejó el sniffing de imagenes, pero experimentando un poco, podemos ver las cookies que se tienen, archivos descargados, conexiones ftp, obtener los usuarios y contraseñas de alguna página que maneje logins, conversaciones de los usuarios en los chats, entre una infinidad de opciones.

Referencias

http://www.flu-project.com/recuperacion-de-imagenes-con-wireshark.html

http://infoobera.blogspot.mx/2011/02/analisis-de-trafico-en-redes-lan-con.html

http://searchdatacenter.techtarget.com/es/cronica/Las-mejores-practicas-de-olfateo-inalambrico-usando-Wireshark

http://www.howtogeek.com/104278/how-to-use-wireshark-to-capture-filter-and-inspect-packets/
http://cdn.memegenerator.net/instances/400x/31207816.jpg

PIL: Putpixel and Getpixel vs Array

En ésta entrada, veremos una comparativa respecto a la demora que se lleva en el procesamiento de una imagen con la librería de PIL.
Realizando las tareas respecto al tema, me encontré con un ligero problema que al analizarlo y compararlo tiene consecuencias como esperar un resultado de una determinada imagen. Así que me puse a investigar y buscar otra forma del poder procesar una imagen con PIL y me encontré con el uso de arreglos manipulados con la misma imagen.

Breve discusión:
Siendo un poco breve y analizando mi código encontré que las subrutinas getpixel y putpixel son un poco pesadas, ya que estamos manipulando y procesando la imagen en el momento que se carga determinado pixel y su determinado color, a comparación del uso de las listas con la subrutina load() donde cargamos la imagen en el arreglo, donde cada elemento contiene una tupla, siendo más ligera y fácil su manipulación.

Código:
En el siguiente código veremos como trabaja el procesar una imagen con lo ya antes mencionado aplicada a una imagen normal buscando obtener la escala de grises.

img.putpixel() & img.getpixel

	def grayScale(self):
	start = time.time()
	self.rgb = self.img.convert('RGB')
	for i in range(self.img.size[0]):
	for j in range(self.img.size[1]):
	r = self.rgb.getpixel((i, j))[0]
	g = self.rgb.getpixel((i, j))[1]
	b = self.rgb.getpixel((i, j))[2]
	media = (r+g+b)/3
	pixel = tuple([media, media, media])
	self.img.putpixel((i, j), pixel)
	self.img.save('grayScale.png', 'PNG')
	end = time.time()
	print 'Tiempo tomado: '+str(end-start)
	return self.img

view raw putpixel&getpixel.py hosted with ❤ by GitHub

img.load()

	def grayScale2(self):
	start = time.time()
	w, h = self.img.size
	for i in range(w):
	for j in range(h):
	r = self.pixel[i,j][0]
	g = self.pixel[i,j][1]
	b = self.pixel[i,j][2]
	media = (r+g+b)/3
	self.pixel[i,j] = (media, media, media)
	self.img.save('grayScale.png', 'PNG')
	end = time.time()
	print 'Tiempo tomado: '+str(end-start)
	return self.img

view raw loadImageArray.py hosted with ❤ by GitHub

Resultados:

[511x684]

[511x684]

Como podemos notar en la siguiente imagen haciendo varios test de la misma imagen se encontró que el primer tiempo arrojado emplea el uso de getpixel y putpixel teniendo una demora aproximada de 3.2 segundos y en el segundo empleado el uso de arreglos obtuvo una demora aproximada de 0.7 segundos.
Podemos discutir que se tiene una reducción del 82% del tiempo empleado, siendo una mejora muy significante en el tiempo al momento de manipular imagenes.

Código Completo:

	from PIL import Image
	from sys import argv
	import time
	class Filtro(object):
	"""docstring for Filtro"""
	def __init__(self, fileName):
	self.img = Image.open(fileName)
	self.pixel = self.img.load()
	def grayScale(self):
	start = time.time()
	self.rgb = self.img.convert('RGB')
	for i in range(self.img.size[0]):
	for j in range(self.img.size[1]):
	r = self.rgb.getpixel((i, j))[0]
	g = self.rgb.getpixel((i, j))[1]
	b = self.rgb.getpixel((i, j))[2]
	media = (r+g+b)/3
	pixel = tuple([media, media, media])
	self.img.putpixel((i, j), pixel)
	self.img.save('grayScale.png', 'PNG')
	end = time.time()
	print 'Tiempo tomado: '+str(end-start)
	return self.img
	def grayScale2(self):
	start = time.time()
	w, h = self.img.size
	for i in range(w):
	for j in range(h):
	r = self.pixel[i,j][0]
	g = self.pixel[i,j][1]
	b = self.pixel[i,j][2]
	media = (r+g+b)/3
	self.pixel[i,j] = (media, media, media)
	self.img.save('grayScale.png', 'PNG')
	end = time.time()
	print 'Tiempo tomado: '+str(end-start)
	return self.img
	def main():
	im = argv[1]
	imagen = Filtro(im)
	imagen.grayScale()
	imagen.grayScale2()
	main()

view raw CodigoCompletoPutPixelVSArray.py hosted with ❤ by GitHub

Actividad 2: Ruido Sal y Pimienta

En esta entrada veremos como meter y quitar ruido. El ruido que se empleará es sal y pimienta en la cuál consiste que en una imagen dada tiene algunos pixeles en blanco y negro.

Importancia

Es importante saber como quitar en una imagen ruido, ya que nos podemos encontrar que en un imagen   su contenido sea afectado por la lente de la cámaras, ondas magnéticas, entre otras.

Sal y Pimienta

Para generar el ruido lo que se pide es la intensidad, donde nos servirá para que tan frecuente tendremos ruido en la image, entonces lo que hacemos es tomar un de forma aleatoria aleatoria, para después darle a ese mismo pixel una tonalidad blanca o negra.

	def sal_pimienta(self, inensidad):
	w, h = self.img.size
	self.pixel = self.img.load()
	intesidad = 0.05
	for i in range(w):
	for j in range(h):
	if(random() <= intesidad):
	if(randrange(1,3) == 1):
	self.pixel[i,j] = (0, 0, 0)
	else:
	self.pixel[i,j] = (255, 255, 255)
	self.img.save('salPimienta05.png', 'PNG')
	return self.img

view raw gistfile1.py hosted with ❤ by GitHub

[intensidad 0.01]

[intensidad 0.05]

[intensidad 0.1]

Remover Sal y Pimienta

Para remover el pixel de sal y pimienta, se pueden emplear varias técnicas, en mi caso empleo la técnica de media aritmética, donde consiste en tomar el pixel actual y sus vecinos, dentro de cada pixel estará su rgb, así que lo ordenamos y sacamos su valor medio, para después meterlo a la lista donde pondremos el actual con sus vecinos, para hacer nuevamente el mismo proceso, que es ordenarlo y sacar el valor medio, una vez obtenido ese valor es el que se pondrá en el pixel actual.

	def remove_sal_pimienta(self):
	w, h = self.img.size
	self.pixel = self.img.load()
	for i in range(w):
	for j in range(h):
	p_a = []
	actual = []
	arriba = []
	abajo = []
	izq = []
	der = []
	actual.append(self.pixel[i,j][0])
	actual.append(self.pixel[i,j][1])
	actual.append(self.pixel[i,j][2])
	actual.sort()
	p_a.append(actual[1])
	if(i-1 >= 0):
	izq.append(self.pixel[i-1,j][0])
	izq.append(self.pixel[i-1,j][1])
	izq.append(self.pixel[i-1,j][2])
	izq.sort()
	p_a.append(izq[1])
	if(i+1 < w):
	der.append(self.pixel[i+1,j][0])
	der.append(self.pixel[i+1,j][1])
	der.append(self.pixel[i+1,j][2])
	der.sort()
	p_a.append(der[1])
	if(j-1 >= 0):
	arriba.append(self.pixel[i,j-1][0])
	arriba.append(self.pixel[i,j-1][1])
	arriba.append(self.pixel[i,j-1][2])
	arriba.sort()
	p_a.append(arriba[1])
	if(j+1 < h):
	abajo.append(self.pixel[i,j+1][0])
	abajo.append(self.pixel[i,j+1][1])
	abajo.append(self.pixel[i,j+1][2])
	abajo.sort()
	p_a.append(abajo[1])
	p_a.sort()
	p = p_a[int(len(p_a)/2)]
	self.pixel[i,j] = (p, p, p)
	self.img.save('quitarSalPimienta.png', 'PNG')
	return self.img

view raw gistfile1.py hosted with ❤ by GitHub

Resultado:

A continuación dejo el resultado y como podemos ver en la imagen que se removió sal y pimienta es casi efectivo, ya que podemos ver a simple vista uno o dos pixeles con ruido.

[Sal y Pimienta]

[Remover Sal y Pimienta]

Código Completo:

	from PIL import Image
	from sys import argv
	import math, time
	from random import randrange, random
	class Filtro(object):
	"""docstring for Filtro"""
	def __init__(self, fileName):
	self.img = Image.open(fileName)
	self.pixel = self.img.load()
	def grayScale(self):
	start = time.time()
	w, h = self.img.size
	for i in range(w):
	for j in range(h):
	r = self.pixel[i,j][0]
	g = self.pixel[i,j][1]
	b = self.pixel[i,j][2]
	media = (r+g+b)/3
	self.pixel[i,j] = (media, media, media)
	self.img.save('grayScale.png', 'PNG')
	end = time.time()
	print 'Tiempo tomado: '+str(end-start)
	return self.img
	def blurFilter(self, repeticiones):
	w, h = self.img.size
	self.pixel = self.img.load()
	if(repeticiones == None): repeticiones = 5
	for n in range(repeticiones):
	for i in range(w):
	for j in range(h):
	array_prom = []
	if(i-1 >= 0):
	array_prom.append(self.pixel[i-1,j][0])
	if(i+1 < w):
	array_prom.append(self.pixel[i+1,j][0])
	if(j-1 >= 0):
	array_prom.append(self.pixel[i,j-1][0])
	if(j+1 < h):
	array_prom.append(self.pixel[i,j+1][0])
	npixel = sum(array_prom)/len(array_prom)
	self.pixel[i,j] = (npixel, npixel, npixel)
	self.img.save('blurFilter.png', 'PNG')
	return selg.img
	def sal_pimienta(self, inensidad):
	w, h = self.img.size
	self.pixel = self.img.load()
	intesidad = 0.05
	for i in range(w):
	for j in range(h):
	if(random() <= intesidad):
	if(randrange(1,3) == 1):
	self.pixel[i,j] = (0, 0, 0)
	else:
	self.pixel[i,j] = (255, 255, 255)
	self.img.save('salPimienta05.png', 'PNG')
	return self.img
	def remove_sal_pimienta(self):
	w, h = self.img.size
	self.pixel = self.img.load()
	for i in range(w):
	for j in range(h):
	p_a = []
	actual = []
	arriba = []
	abajo = []
	izq = []
	der = []
	actual.append(self.pixel[i,j][0])
	actual.append(self.pixel[i,j][1])
	actual.append(self.pixel[i,j][2])
	actual.sort()
	p_a.append(actual[1])
	if(i-1 >= 0):
	izq.append(self.pixel[i-1,j][0])
	izq.append(self.pixel[i-1,j][1])
	izq.append(self.pixel[i-1,j][2])
	izq.sort()
	p_a.append(izq[1])
	if(i+1 < w):
	der.append(self.pixel[i+1,j][0])
	der.append(self.pixel[i+1,j][1])
	der.append(self.pixel[i+1,j][2])
	der.sort()
	p_a.append(der[1])
	if(j-1 >= 0):
	arriba.append(self.pixel[i,j-1][0])
	arriba.append(self.pixel[i,j-1][1])
	arriba.append(self.pixel[i,j-1][2])
	arriba.sort()
	p_a.append(arriba[1])
	if(j+1 < h):
	abajo.append(self.pixel[i,j+1][0])
	abajo.append(self.pixel[i,j+1][1])
	abajo.append(self.pixel[i,j+1][2])
	abajo.sort()
	p_a.append(abajo[1])
	p_a.sort()
	p = p_a[int(len(p_a)/2)]
	self.pixel[i,j] = (p, p, p)
	self.img.save('quitarSalPimienta.png', 'PNG')
	return self.img
	def main():
	im = argv[1]
	imagen = Filtro(im)
	imagen.grayScale()
	imagen.sal_pimienta(5)
	#imagen.remove_sal_pimienta()
	main()

view raw gistfile1.py hosted with ❤ by GitHub

Referencias:

alojamientos.us.es/gtocoma/pid/tema3-1.pdf
http://es.wikipedia.org/wiki/Ruido_en_la_fotograf%C3%ADa_digital
www4.ujaen.es/~satorres/practicas/practica2.pdf

Actividad 2: Infográfico

Imagen:

Tarea 2: Protocolo UDP

Para ésta entrada se trabajo con el protocolo UPD, definiendo un poco, podemos decir que un protocolo es un conjunto de reglas que rigen el formato y significado de paquetes o mensajes. o de una forma más sencilla explicado es el acuerdo entre dos partes que se comunican para establecer la forma en la que se llevará la comunicación

Para una comunicación se tienen dos términes que debemos entender el cuál es servicio y protocolo, el segundo ya definido y el primero definido a continuación:

Servicio:
Es el conjunto de operaciones que una capa proporciona a la capa que esta encima de ellos. En esta se define que operaciones puede realizar la cara en beneficios de sus usuarios

UPD
El protocolo UDP es un protocolo no orientado a conexión, conocido también como datagrama que es un servicio sin conexión no confiable, ya que no se tiene una obligación de confirmar la recepción, por que no es obligatorio poner en la estructura del protocolo el origen del paquete.

El udp es implementado en la aplicación de SPAM, mensajería de texto y consultas en Base de Datos.

En ésta entrada, se realizo un pequeño programa que es adivinar un número, donde se muestra la implementación de UDP con el envió de paquetes, en sí el programa es muy sencillo ya que lo que hace es establecer una conexión entre cliente y servidor y el cliente dice un número entre 1 y 5 para mandarlo al servidor, el servidor ve el tamaño del paquete en lo descomprime y verifica si el número es adivinado, si es asi sube la puntuación.

Código Servidor:

	import socket
	import struct
	import random
	UDP_IP = "127.0.0.1"
	UDP_PORT = 5008
	sock = socket.socket( socket.AF_INET, socket.SOCK_DGRAM )
	sock.bind( (UDP_IP,UDP_PORT) )
	suma = 0
	while True:
	data, addr = sock.recvfrom( 1024 ) # buffer size is 1024 bytes
	print data
	valor = random.randrange(1,5)
	data = struct.unpack("i",data)
	print 'El tamanio del paquete es: '+str(len(data))+' byte(s)'
	if(data == valor):
	suma += 1
	print 'Adivinaste'
	else:
	print 'No fue el numero'
	print 'Tu puntuacion es: '+str(suma)+'\n'
	print addr[0]
	suma = str(suma)
	sock.sendto(suma, (addr[0], UDP_PORT))

view raw gistfile1.py hosted with ❤ by GitHub

Código Cliente:

	from sys import argv
	import socket
	import struct
	UDP_IP = "127.0.0.1"
	UDP_PORT = 5008
	sock = socket.socket( socket.AF_INET, # Internet
	socket.SOCK_DGRAM ) # UDP
	while True:
	print 'Ingresa un numero entre 1 y 5: '
	valor = raw_input()
	valor = struct.pack("i",int(valor))
	sock.sendto(valor, (UDP_IP, UDP_PORT))
	data = sock.recvfrom( 1024 ) # buffer size is 1024 bytes
	if(data != ''):
	print data

view raw gistfile1.py hosted with ❤ by GitHub

Resultados
A continuación se muestra una imagen con los resultados obtenido entre la comunicación de ambos:

Referencia:
http://codeprogress.com/python/libraries/standard%20python/showPythonExample.php?index=9&key=SendReceiveBinaryDataUDP#.URbwPlrm63q
http://mundogeek.net/archivos/2008/04/12/sockets-en-python/