Lab 4: Detección de lineas diagonales

Para el laboratorio de visión computacional se nos pide detectar lineas diagonales, es por eso que utilizando la transformada de Hough y utilizando las mascaras de gradiente para 0 y 90 grados de Pewitt, detecto las lineas horizontales, verticales y diagonales de una imagen.

Mi repositorio de los códigos. Liga.

Primero que nada, sacamos el gradiente de tal forma que podamos analizar la imagen.

Para luego, procesarlo de manera que tengamos su ángulo y rho de cada pixel, luego generamos un histograma para sacar los más significativos y los pintamos de manera que un color el cual tenga cierto ángulo son verticales, horizontales y diagonales, este es el código.

	def linea(imagen_Y, imagen_X, w, h, imagen, incluir):
	resultado = list()
	for y in range(h):
	datos = list()
	for x in range(w):
	pixel_X = float(sum(imagen_X[x, y]))/3.0
	pixel_Y = float(sum(imagen_Y[x, y]))/3.0
	print str(pixel_X) + " " + str(pixel_Y)
	if fabs(pixel_X) > CERO:
	angulo = atan(pixel_Y/pixel_X)
	else:
	if fabs(pixel_X) + fabs(pixel_Y) <= CERO:
	angulo = None
	elif pixel_X == 0.0 and pixel_Y == 255.0:
	angulo = 90.0
	else:
	angulo = 0.0
	if angulo is not None:
	rho = (x - w/2) * cos(angulo) + (h/2 - y) * sin(angulo)
	datos.append(('%.2f' % angulo, '%.0f' % rho))
	else:
	datos.append((None, None))
	resultado.append(datos)
	comb = dict()
	for y in xrange(h):
	for x in xrange(w):
	if x > 0 and y > 0 and x < w - 1 and y < h - 1:
	(angulo, rho) = resultado[y][x]
	if angulo is not None:
	combinacion = (angulo, rho)
	if combinacion in comb:
	comb[combinacion] += 1
	else:
	comb[combinacion] = 1
	frec = frecuentes(comb, int(ceil(len(comb) * incluir)))
	for y in range(h):
	renglon = list()
	for x in range(w):
	(ang, rho) = resultado[y][x]
	if (ang, rho) in frec:
	if str(ang) == "90.00":
	imagen.putpixel((x,y), (0,255,0))
	elif str(ang) == "0.00":
	imagen.putpixel((x,y), (0,0,255))
	else:
	imagen.putpixel((x,y), (255,0,0))
	imagen.save("Prueba.jpg")
	return imagen

view raw diagonal.py hosted with ❤ by GitHub

Estos son los resultados de la imagen.

Validación de modelos de red inalámbricas móviles usando simuladores

Para la materia de telecomunicación se nos pide realizar una investigación en google scholar en donde tenemos que encontrar un paper en el cual usen un simulador de redes para hacer alguna prueba, es por eso que yo seleccioné Validation of Wireless and Mobile Network Models de David B. Johnson, en donde utiliza el simulador NS2 para hacer pruebas en redes inalámbricas.

Como introducción, nos dice que las redes inalámbricas tienen retos importantes a la hora de validar modelos de redes a gran escala, ya que si bien, la validación en redes convencionales conectadas por cable, existe problemas, a las redes inalámbricas se les agrega un extra lo cual es el movimiento físico y la propagación de la red, siendo una red variable y dependiente de factores que no podemos controlar como es el medio ambiente, paredes, árboles o cualquier obstrucción que tenga alguna red inalámbrica, es por eso que el departamento de informática de Carnegie Mellon University crean un experimento para hacer validación de modelos en redes inalámbricas.

Ellos utilizan el simulador NS2 para observar el comportamiento detallado de la capa física y de enlace de una red inalámbrica, para así permitir el movimiento arbitrario de los nodos en alguna red, en la capa física, se hacen modelos realistas con factores que habíamos descrito anteriormente, como el espacio libre, paredes y la reflexión del suelo, para obtener cierta potencia de transmisión, la ganancia de la antena y la sensibilidad de la recepción, por otra parte en la capa de enlace, utilizan el modelo DCF, Distributed Coordination Function, utilizando la MAC, Media Access Control del protocolo de la IEEE 802.11 inalámbrico LAN, junto con el estándar de Address Resolution Protocol.

Utilizan un baco de pruebas el cual consiste en aproximadamente 5 nodos móviles implementados en carros que viajan aproximadamente 25 millas por hora junto con dos nodos estacionarios separados por una distancia de 700 metros, en cada carro se tiene una computadora que tienen el protocolo de enroutamiento DSR ad hoc, permitiendo el registro local de los eventos de red en el disco duro de cada uno, cuando los carros se movían, utilizando un sistema de seguimiento de GPS, la ruta entre los dos nodos estacionarios iba cambiando constantemente, utilizando un área abierta a trafico de otros carros por lo que la velocidad de cada nodo, variaba con el tiempo, al igual que lo haría con cualquier red real, luego se mandaban datos para realizar el experimento entre el NS2 y con los carros, como flujos constantes de UDP, simulando voces, video, paquetes de información, etc.

Algunos de los resultados que obtuvieron en esta simulación fueron gráficas como la que muestro arriba, en donde muestran tres secuencias de tiempo para una misma simulación y la emulación del protocolo FTP entre los dos nodos estacionarios y una red de 16 nodos ad hoc. podemos ver en la curva superior que muestra una conexión simulada completamente utilizando el NS2 y las otras dos pruebas son haciendolo en forma de emulación, utilizando las técnicas que han desarrollado, podemos ver que son muy parecidas y que es posible su validación entre su simulación y la vida real.

Referencias.
Validation of Wireless and Mobile Network Models, David B. Johnson, Carnegie Mellon University. Liga.

Lab 4: Retroalimentación a proyectos

Para la cuarta entrega de laboratorio de Cómputo Ubicuo, se nos pide realizar retroalimentación con comentarios y observaciones a cada uno de los equipos de la materia, por lo que en base a el diseño conceptual sensible al contexto que presentaron la clase pasa, voy a dar algunas recomendaciones a estos.

Seguridad en computadora.

Su idea está interesante para el desarrollo de un sistema seguro y que ninguna persona pueda utilizar la computadora cuando está bloqueada, les voy a dar una idea que no se si les parezca buena, pero en Android existe una aplicación, en la cual si por ejemplo, yo tengo mi celular bloqueado y alguien intenta desbloquearlo por más de 5 veces, en automático, con la cámara frontal, toma una foto para saber quien es la persona que intenta desbloquearlo y la envía a tu correo, ustedes pueden realizar una idea parecida en que si una persona intenta desbloquear la computadora varias veces, se mande a tu correo la foto de la cara y saber identificar quien fue.

 Una de las cuestiones que deben considerar es el hecho de que tal vez algunas personas no consideren que necesiten un software como este, por lo que de alguna manera deben hacer creer al usuario que es necesario y que les va ayudar a que sea más seguro su computadora.

Galería inteligente.

Una de las ideas que recomendaría para la galería inteligente, yo se que se quieren enfocar a todo tipo de personas, pero tal vez esta idea sería muy innovadora para todos aquellos niños que los mandan de la escuela a un museo, de alguna manera preguntar a los niños y adolescentes de que manera ellos creen que pudieran ir al museo más fácilmente y así atraer la juventud a la galería, esto porque considero que personas que siempre han ido al museo, tal vez no se sientan muy a gusto en el hecho de tener que interactuar con alguna plataforma, entonces hacer encuestas distintas a personas que van seguido al museo, niños y adolescentes que van a museos y personas que no van seguido a un museo, para tener información de estos grupos y hacer una unificación de prototipos.


Oficina inteligente.

Su tema es muy interesante, pero considero que deberían enfocarse en un grupo de cosas específicas en una oficina, en realidad saber que es lo que más necesitan las personas que trabajan en alguna oficina para luego de ahí partir a los prototipos, considero que su proyecto e ideas son bastante completas ya que cuentan con muchos aspectos, podrían mejorar con el hecho de preguntar a personas una lista de prioridades de lo que esperan en una oficina inteligente, de manera que puedan tener diferentes ramas a enfocarse y poder así sacar sus conclusiones del contexto.


Alarma de automóvil

Deberían de demostrar un prototipo de como ustedes quieren que sea el sistema, algo muy simple que de una idea a las personas cómo quieren contribuir en su automóvil, para luego hacer una encuesta en la cual puedan mostrar diferentes prototipos y las personas clasifiquen estos y saber con cual de todos ellos se quedaría, esto incluyendo por ejemplo de que forma ayudarían a demostrar que este sistema es mejor que las alarmas existentes, que otros beneficios pueden tener y así también generar cierto deseo al usuario en base a las preguntas que están realizando en la encuesta.

De esta manera, ustedes tendrán una linea más clara de lo que desean realizar y más fácil de entender para ustedes y para el usuario lo que quieren desarrollar.

Pulsera GPS

Este dispositivo pudiera ser interesante para personas que tienen alguna debilidad mental, al igual que niños, por lo que me gustaría que realizaran encuestas a personas que necesiten este tipo de herramienta, no me refiero a la persona que lo va a portar, si no a madres de familia, familiares de algún paciente, entre otros que pudieran ser personas objetivo de poder comprar el gadget y que cuenten experiencias de como les gustaría que este funcionara, por lo que por ejemplo que si se encuentra a ciertos kilómetros a la redonda muy por afuera de su casa, manda alertas automáticamente, alguna especie de interacción entre diferentes dispositivos y que siempre pueda estar controlado.

Algo interesante sería el agregar la funcionalidad de que sea por ejemplo algún reloj de manera que el niño o la persona que lo utilice no sepa que en realidad esa pulsera es para tener un seguimiento de su ruta.

Carro con NFC.

Me parece una buena idea el ofrecer servicios personalizados con esta tecnología en base al carro y el smartphone, por lo que la idea es interesante, ahora lo que resta es identificar la serie de servicios para clasificarlos de manera que tengamos mini-tareas que tengan cada quien su uso en específico, por ejemplo si un usuario solamente quiere saber la ruta a donde ha viajado los últimos 3 meses, que pueda acceder a ello fácilmente, una de las ideas que considero que deberían tomar en cuenta es el hecho de pueda por ejemplo, al poner el celular en tu carro, conectarse a tu música y que se ponga la que tengas marcada como favorito, de alguna forma personalizar por medio de tu celular las cosas que hace el carro, como perfiles de usuario de que si el carro es compartido, ponga el clima y toque música de cierto tipo diferente a las preferencias de algún otro miembro del carro, me parece muy buena su idea.



Casa segura.

En realidad el tema es muy general, una casa segura abarca muchas cuestiones que hay que considerar en seguridad, por lo que deberían enfocarse en un tema y que ese tema lo desarrollen bien, esto quiere decir que por ejemplo, al hablar de casa segura ustedes solamente se van a enfocar en abrir y cerrar las puertas con smartphones utilizando NFC o que puedas cerrar puertas a distancia, etc..., un tema en específico que puedan desarrollar bien y no hacer múltiples cosas y que ninguna quede terminada.

Luego de definir lo que les expreso anteriormente, ahora volver a hacer una iteración de encuestas de un ramo en específico, seleccionando cuidadosamente que preguntar y que usuarios objetivo, para así reducir los datos obtenidos y enfocarse en un proyecto mejor definido.

Tienen ideas muy bien definidas en las cuales pueden enfocarse más, por ejemplo el crear un sistema que emule la idea de que existe alguien en la casa, yo iría mas por ese enfoque ya que me parece una idea innovadora.



Garage inteligente.

Entre los prototipos que mostrar, me parece que ustedes tienen la idea bien definida de lo que se quiere realizar en su proyecto, por lo que considero que si bien pueden seleccionar uno de estos, o hacer una combinación entre ambos, lo interesante es que es aplicable no nada más a un garage si no, por ejemplo, las puertas del patio o puertas de alguna terraza.

Una idea interesante sería la aplicación del sistema de forma automatizada para los residentes de habitaciones donde comparten estacionamiento, entonces con su celular puedan abrir o cerrar el garaje según algún usuario, si por ejemplo, llega visita, de alguna manera pasar información de tiempo limitado para que puedan abrir el garage.


Esto sería todo para el laboratorio de cómputo ubicuo, si tienen alguna duda o comentario, favor de hacérmelo saber.

Experimentos de QoS

Para la materia de redes de telecomunicaciones se nos pide realizar un experimento de manera que podamos comprobar que tan bueno es el servicio que se nos ofrece en diferentes aplicaciones en diferentes conexiones, es por eso que para esta entrada he seleccionado la calidad de servicio de QoS entre fibra óptica, conexión por cable y wireless en streaming de videos de youtube.

Valores a comprobar.

En este experimento estoy tomando en cuenta los kilobits por segundo que se está descargando en un streaming de video, comparado con el tiempo que se está tardando en hacer esa cantidad, en donde podemos observar que tan rápido está descargando los videos para que el usuario los pueda ver correctamente, el experimento es bueno cuando si el video es de una longitud mayor a la que tenemos de la descarga, podemos decir que el usuario pudo verlo sin problemas ni retardos, cuando no es así quiere decir que tuvo que soportar cierto retraso.

Es por eso que para este experimento, estamos realizando pruebas con los siguientes valores:

• Un video de aproximadamente 3 minutos (liga) en el cual tenga las siguientes resoluciones disponibles:
• 480p
• 720p
• 1080p
• 4k
• Utilizando los siguientes métodos de conexión
• Conexión por cable coaxial de 5 megas.
• Conexión inalámbrica de 5 megas.
• Conexión fibra óptica de 20 megas.
• Uso de comando ifstat para obtener los kbps en tiempo real
• Uso de gnuplot para realizar las gráficas.

Conexión inalámbrica.

En mi caso utilizo mi red de INTERCABLE de manera que utiliza conexión por cable coaxial a mi computadora inalambricamente, de una velocidad aproximada de 5 megas, en donde obtuvimos los siguientes resultados.

Podemos observar los siguientes puntos relevantes.

• El video en resolución 720p termina más rápido que las demás resoluciones (debería ser 480p).
• Los videos de resoluciones 1080p, 720p y 480p son vistos sin ningún retraso, aproximadamente demoran 120 segundos o menos en cargar.
• El video en resolución 4k demora más de 8 minutos para cargar, cuando su longitud es de 3 min, por lo que tenemos un retraso que hace que no podamos ver el video fluidamente.

Ahora expongo los resultados individuales.

Conexión alámbrica.

Ahora se utiliza la red de INTERCABLE de 5 megas alambricamente, en donde tenemos los siguientes resultados.

Vemos que de manera alámbrica es más estable que la inalámbrica al hacer streaming de video, al igual que la cantidad de tiempo es menor basada en la anterior, puntos destacables:

• La resolución de 480p carga en menos de 1 minuto
• Las resoluciones menores a 4k cargan sin retrasos y son menores que la longitud del video.
• 4k carga 100 segundos menos que inalambricamente, podemos ver una mejora al estar conectados directamente al router.

Ahora expongo los resultados individuales.

Conexión fibra óptica.

Para la conexión de fibra óptica se utiliza la red INFINITUM de 20 megas, el cual es considerablemente más rápida que la anterior experimentada, obtenemos los siguientes valores:

Vemos que al conectarnos en fibra óptica es más rápida, carga aproximadamente 40% más rápido que de las formas anteriores, aunque debería ser aún más el cambio, he observado que Telmex, tiene un cierto regulador de vídeos de manera que hace que no utilice todo el ancho de banda para descargar los videos, entre los puntos relevantes podemos decir que:

• La descarga de video en 480p fue menos rápido que los anteriores, tardando 120 segundos, cuando en la anterior tardó 60 segundos.
• La descarga de video en 1080p y 4k fueron considerablemente mejorados que los anteriores.
• Aún con fibra óptica, los videos de 4k no fueron vistos según el análisis, sin observar retraso, tardando aproximadamente más de 5 minutos en cargar, cuando la longitud del video es de 3 min.
• Vemos más picos y inestabilidad en esta señal.

Conclusión

Cómo conclusion podemos decir que de manera alámbrica en INTERCABLE tenemos una conexión mejor para observar videos, a pesar de que este proveedor ofrece 5 megas, es más estable, en lo que respecta a la fibra óptica de Telmex, vemos mucha inestabilidad al momento de ver videos, a menos que sean de resolución alta, se ve una mejora, pero igual se pueden observar retrasos, esto lo considero muy desagradable, los picos de Telmex, llegan hasta 18000 kbps pero solamente algunas veces, cuando en Intercable llega a picos 9000 y se mantiene en ellos, proporcionando una conexión más constante.

Detección de Lineas.

Para la materia de visión computacional se nos pide detectar lineas, es por eso que utilizando la transformada de Hough y utilizando las mascaras de gradiente para 0 y 90 grados de Pewitt, detecto las lineas horizontales y verticales de una imagen.

Mi repositorio de los códigos. Liga.

Primero que nada, sacamos el gradiente de tal forma que podamos analizar la imagen.

Para luego, procesarlo de manera que tengamos su ángulo y rho de cada pixel, luego generamos un histograma para sacar los más significativos y los pintamos de manera que un color el cual tenga cierto ángulo son verticales u horizontales, este es el código.

	def linea(imagen_Y, imagen_X, w, h, imagen, incluir):
	resultado = list()
	for y in range(h):
	datos = list()
	for x in range(w):
	pixel_X = float(sum(imagen_X[x, y]))/3.0
	pixel_Y = float(sum(imagen_Y[x, y]))/3.0
	if fabs(pixel_X) > CERO:
	angulo = atan(pixel_Y/pixel_X)
	else:
	if fabs(pixel_X) + fabs(pixel_Y) <= CERO:
	angulo = None
	elif pixel_Y == 255 and pixel_X == 0:
	angulo = 90.0
	else:
	angulo = 0.0
	if angulo is not None:
	rho = (x - w/2) * cos(angulo) + (h/2 - y) * sin(angulo)
	datos.append(('%.2f' % angulo, '%.0f' % rho))
	else:
	datos.append((None, None))
	resultado.append(datos)
	comb = dict()
	for y in xrange(h):
	for x in xrange(w):
	if x > 0 and y > 0 and x < w - 1 and y < h - 1:
	(angulo, rho) = resultado[y][x]
	if angulo is not None:
	combinacion = (angulo, rho)
	if combinacion in comb:
	comb[combinacion] += 1
	else:
	comb[combinacion] = 1
	frec = frecuentes(comb, int(ceil(len(comb) * incluir)))
	for y in range(h):
	renglon = list()
	for x in range(w):
	(ang, rho) = resultado[y][x]
	if (ang, rho) in frec:
	if str(ang) == "90.00":
	imagen.putpixel((x,y), (255,0,0))
	if str(ang) == "0.00":
	imagen.putpixel((x,y), (0,255,0))
	imagen.save("Prueba.jpg")
	return imagen

view raw prueba.py hosted with ❤ by GitHub

Estos son los resultados de la imagen.

Original

Procesada

Original

Procesada

Lab 4: Técnicas de aseguramiento QoS

En lo que respecta a las telecomunicaciones, la multimedia ha ido incorporandose a nuestra vida diaria, de hecho cuando nosotros nos metemos a la radio de internet o vemos películas en netflix, estamos interactuando con la multimedia de los dispositivos al ofrecer de diferentes formas un servicio de video, audio, etc, es por eso que para esta entrada de laboratorio, vamos a hablar acerca de la calidad de servicio de la multimedia y algunas tecnicas que se pueden utilizar para saber si nos ofrece la calidad que el usuario desea.

Aplicaciones multimedia

Las aplicaciones multimedia refiere a el transpaso de flujo continuo de audio/video a través de la red, en donde la calidad de servicio hace que las aplicaciones tengan un buen nivel de performance necesario para su buen funcionamiento.

Existen diferentes clases de aplicaciones multimedia, por ejemplo streaming de audio y video que se grabó con anterioridad, streaming de audio y video en directo y también aplicaciones de audio y video interactivos, las principales características de estas aplicaciones es que son sensibles al tiempo, por ejemplo ver pedazos cortados, interfiriendo una cierta fluctuación (en inglés jitter), por lo tanto debe ser capaz de ser tolerante y sensible a demoras y perdidas de información.

Los protocolos en el streaming

El streaming es la manera de obtener datos de media que están guardados en una fuente (por ejemplo VoD), transmitiendo al cliente cuando comienza a dar play antes de que todos los datos lleguen al receptor, mientras transmite este sigue recibiendo flujo de datos sin que se guarde dentro del cliente, por lo que encontramos restricciones de tiempo que hace que dichos datos puedan ser vistos al recibir flujo, por que si esperamos el flujo completo, sería una trasferencia de archivo, en realidad en streaming se necesita verlo antes de que todo el fluje termine de obtenerlo, entre las demás clases streaming podemos encontrar cuando es directo, tiempo real, donde podemos encontrar la telefonía IP, video conferencias, juegos distribuidos, etc, en donde un valor promedio de calidad de servicio en este tipo de streaming es menor de 150 mili segundos como una conexión buena y menos de 400 mili segundos como aceptable.

La multimedia básica en internet esta basada en los protocolos TCP/UDP/IP, de forma que cada uno hace su mejor esfuerzo para garantizar que no existan plazos sin datos o delays (UDP, TCP) ni perdidas de partes o contenido (UDP).

Con el protocolo TCP existe el siguiente flujo de datos de manera que realiza:

1. Corrección de perdida. 
2. Retransmisión 
3. Aumentar retardo y jitter.

Actualmente, las aplicaciones multimedia utilizan técnicas en la capa de aplicación como hacer codificación y realizar playback en el buffer, para esconder o disminuir las limitaciones del proveedor de internet.


Mediciones.

Para asegurar que el QoS este funcionando correctamente dentro de alguna red, luego de las técnicas mencionadas anteriormente, se pueden hacer gráficamente el análisis para averiguar si estas son recomendables o no, entre las gráficas que se pueden generar son los siguientes:

• Sacar el promedio de entre los bytes descargados y el tiempo.
• El instante de empezar a descargar entre la hora
• Obtener la media de los datos durante el inicio del buffering
• Graficar los datos descargados al inicio del buffering
• Obtener la longitud del video sobre el tiempo de descarga
• El tiempo de descarga al iniciar un video
• Entre otros.

Por ejemplo, para la tarea de esta materia, estuve trabajando en implementar un experimento que graficara en videos de longitud de 3 minutos, con diferentes formas de internet (cableado analógico, wireless, fibra óptica), para sacar un promedio entre los bytes descargados y el tiempo.

Por ejemplo en videos de resolución 4k, que duran aproximadamente 3 min, podemos encontrar que se termina de descargar a los 500 segundos, aproximadamente 8 min, por lo que no tenemos una buena relación entre calidad de servicio, ya que esta demora más que lo que tarda el video, cosa que se debe de evitar en streaming de video.

Esto cambia radicalmente, cuando tenemos varios dispositivos a la vez al querer hacer streaming de video de 4k, por lo que existen diferentes mecanismos que pretenden arreglar esta situación.


Mecanismos de gestión de tráfico.

Existen diferentes arquitecturas y protocolos utilizado para saber asegurar que existe una buena calidad en el servicio de la red, conocidas para dar soporte a los datos multimedia, entre ellos podemos mencionar los siguientes:

Arquitectura integrado al servicio (IntServ):

Algunas veces, para todos los paquetes IP, tienden a ser tratados de la misma manera sin ninguna diferenciación, por lo tanto, un flujo de streaming en tiempo real, son tratados como servicio Mejor esfuerzo, en donde se almacenan en la cola de acuerdo con el principio FIFO (First In First Out), por lo tanto el tiempo de transmisión puede ser largo y sobre todo no constante existiendo el Jitter, un fenómeno que los medios de transmisión es muy sensible a darse.

El modelo IntServ define una arquitectura capaz de soportar QoS utilizando mecanismos de control adicionales sin afectar el funcionamiento de IP. Se trata de un modelo basado en el protocolo RSVP, este modelo hace que los router reserven recursos para un flujo de datos específico mediante el almacenamiento de información, definiendo dos tipos de servicio.

• Garantía de Servicio (GS) que garantiza el ancho de banda limitado y tiempo de entrega, se debe a que los datagramas se incluirán en el plazo de entrega grantizado y no se descarta debido a desbordamientos de la cola.

• Carga controlado, equivalente al servicio de mejor esfuerzo en un entorno que no está sobrecargado.

Arquitectura diferencia de servicio (DiffServ):

Como pueden ver, el IntServ es difícil de aplicar para grandes redes ya que es difícil mantener un estado de los recursos de la red para cada flujo si por ejemplo esta cambia a cada rato, es por eso que surge la arquitectura DiffServ el cual clasifica el tráfico con un código en el paquete IP, aplicando un trato diferenciado a las distintas clases de tráfico.

Cada clase es identificada por un valor de código haciendo que la entrada de red dentro del router se dirija a la dirección IP asignada, permitiendo que cada IP pueda ser controlado según su flujo de datos, según el RFC 2475.

El DiffServ tiene dos elementos fundamentales:

• Los edge functions, las cuales los routes accedan según la red ISP, responsables de la clasificación de paquetes y el condicionamiento de trafico.

• Los core functions, responsables de enviar únicamente, cuando un paquete es marcado en cierto campo de DS, puede enviar el siguiente flujo.

802.1p

802.1p es un mecanismo de gestión adecuado para el trafico agregado en redes LAN, este mecanismo básicamente define un campo en la cabecera MAC en los paquetes de Ethernet, que puede contener uno de los ocho niveles de prioridad posibles. Los rotures que llevan el tráfico a una LAN va checando el nivel de prioridad de paquetes de transmisión, según corresponde. Los dispositivos LAN, inlcuyendo los switches, gateways y los AP deben tratar los paquetes de acuerdo a su prioridad.

Esto sería todo para la entrada de técnicas para el aseguramiento de QoS, si tienen alguna duda o comentario.

Referencias.
Les mécanismes de controle de la qualité de service dans les réseaux informatiques. Bernard Cousin (Liga).
Estudio e Implementación de Calidad de Servicio. Universidad de Cartagena. Liga.

Lab 3: Convex hull

Para el laboratorio numero 3 de la materia de Visión Computacional se nos pide realizar un algoritmo de convex hull, para esto, seleccione el gift wrapping, también conocido marcha de Jarvis en versión 2 dimensional.

Hice un preprocesamiento para empezar a utilizar el gift wrapping, primero, utilicé el mismo código que  había utilizando para detectar formas, pero ahora en los bordes que están de color blanco, estos los cambio de color y guardo todos los pixeles para ponerlos en el algoritmo de convex hull.

Luego de preprocesar la información, entra al algoritmo, el cual va verificando las direcciones izquierdas mas próximas para ir formando el polígono, el cual lo pongo con unas lineas rojas utilizando PIL de python.

Estas son algunas capturas de mis pruebas

Este es el código.

	from Tkinter import *
	from PIL import Image, ImageTk, ImageDraw
	from math import floor
	import numpy
	import random
	def ventana():
	root = Tk()
	root.title('Lab 3')
	global frame
	frame = Frame()
	frame.pack(padx=5,pady=5)
	poner_imagen(obtener_original(path_imagen_original))
	b1 = Button(text='Original', command = boton_original).pack(in_=frame, side=LEFT)
	b4 = Button(text='Identificar', command = boton_bordes).pack(in_=frame, side=LEFT)
	root.mainloop()
	def poner_imagen(image):
	photo = ImageTk.PhotoImage(image)
	global label
	label = Label(image=photo)
	label.imagen = photo
	label.pack()
	def BFS(imagen, inicio, color):
	pixeles = imagen.load()
	altura, ancho = imagen.size
	fila, columna = inicio
	original = pixeles[fila, columna]
	cola = []
	cola.append((fila, columna))
	masa = []
	pixeles_BFS = []
	while len(cola) > 0:
	(fila, columna) = cola.pop(0)
	actual = pixeles[fila, columna]
	if actual == original or actual == color:
	for dx in [-1, 0, 1]:
	for dy in [-1, 0, 1]:
	candidato = (fila + dy, columna + dx)
	if candidato[0] >= 0 and candidato[0] < altura and candidato[1] >= 0 and candidato[1] < ancho:
	contenido = pixeles[candidato[0], candidato[1]]
	if contenido == original:
	pixeles[candidato[0], candidato[1]] = color
	imagen.putpixel((candidato[0], candidato[1]), color)
	cola.append(candidato)
	masa.append((candidato[0], candidato[1]))
	pixeles_BFS.append((candidato[0], candidato[1]))
	return imagen, masa, pixeles_BFS
	def cambiar_agrises(path_original):
	imagen = Image.open(path_imagen_original).convert("RGB")
	pixeles = imagen.load()
	x, y = imagen.size
	imagen_nueva = Image.new("RGB", (x, y))
	colores = []
	for a in range(x):
	for b in range(y):
	pixel_color = pixeles[a, b]
	promedio = sum(pixel_color)/3
	tupla_promedio = (promedio, promedio, promedio)
	colores.append(tupla_promedio)
	imagen_nueva.putpixel((a, b), tupla_promedio)
	return imagen_nueva
	def cambiar_promedio(imagen):
	pixeles = imagen.load()
	x, y = imagen.size
	imagen_nueva_prom = Image.new("RGB", (x, y))
	colores = []
	for a in range(x):
	for b in range(y):
	pixel_color = pixeles[a, b]
	veces = 5
	suma = 0
	promedio = 0
	try:
	pixel_norte = pixeles[a-1,b]
	except IndexError:
	pixel_norte = (0, 0, 0)
	veces = veces - 1
	try:
	pixel_sur = pixeles[a+1, b]
	except IndexError:
	pixel_sur = (0, 0, 0)
	veces = veces - 1
	try:
	pixel_este = pixeles[a, b+1]
	except IndexError:
	pixel_este = (0, 0, 0)
	veces = veces - 1
	try:
	pixel_oeste = pixeles[a, b-1]
	except IndexError:
	pixel_oeste = (0, 0, 0)
	veces = veces - 1
	Rojos_suma = pixel_norte[0] + pixel_sur[0] + pixel_este[0] + pixel_oeste[0] + pixel_color[0]
	Verdes_suma = pixel_norte[1]+ pixel_sur[1] + pixel_este[1] + pixel_oeste[1] + pixel_color[1]
	Azul_suma = pixel_norte[2]+ pixel_sur[2] + pixel_este[2] + pixel_oeste[2] + pixel_color[2]
	Rojo_prom = Rojos_suma/veces
	Verdes_prom = Verdes_suma/veces
	Azul_prom = Azul_suma/veces
	tupla_promedio = (Rojo_prom, Verdes_prom, Azul_prom)
	colores.append(tupla_promedio)
	imagen_nueva_prom.putpixel((a, b), tupla_promedio)
	return imagen_nueva_prom
	def diferencia(imagen):
	pixeles = imagen.load()
	x, y = imagen.size
	imagen_nueva_prom = Image.new("RGB", (x, y))
	colores = []
	for a in range(x):
	for b in range(y):
	pixel_color = pixeles[a, b]
	veces = 5
	suma = 0
	promedio = 0
	try:
	pixel_norte = pixeles[a-1,b]
	except IndexError:
	pixel_norte = (0, 0, 0)
	veces = veces - 1
	try:
	pixel_sur = pixeles[a+1, b]
	except IndexError:
	pixel_sur = (0, 0, 0)
	veces =veces - 1
	try:
	pixel_este = pixeles[a, b+1]
	except IndexError:
	pixel_este = (0, 0, 0)
	veces =veces - 1
	try:
	pixel_oeste = pixeles[a, b-1]
	except IndexError:
	pixel_oeste = (0, 0, 0)
	veces =veces - 1
	Rojos_suma = pixel_norte[0] + pixel_sur[0] + pixel_este[0] + pixel_oeste[0] + pixel_color[0]
	Verdes_suma = pixel_norte[1]+ pixel_sur[1] + pixel_este[1] + pixel_oeste[1] + pixel_color[1]
	Azul_suma = pixel_norte[2]+ pixel_sur[2] + pixel_este[2] + pixel_oeste[2] + pixel_color[2]
	Rojo_prom = Rojos_suma/veces
	Verde_prom = Verdes_suma/veces
	Azul_prom = Azul_suma/veces
	Rojo_dif = pixel_color[0] - Rojo_prom
	Verde_dif = pixel_color[1] - Verde_prom
	Azul_dif = pixel_color[2] - Azul_prom
	tupla_promedio = (Rojo_dif, Verde_dif, Azul_dif)
	colores.append(tupla_promedio)
	imagen_nueva_prom.putpixel((a, b), tupla_promedio)
	return imagen_nueva_prom
	def normalizacion(imagen):
	pixeles = imagen.load()
	x, y = imagen.size
	min = 0
	max = 0
	imagen_nueva = Image.new("RGB", (x, y))
	for a in range(x):
	for b in range(y):
	pixel_color = pixeles[a, b]
	max_ant = max
	max_new = pixel_color[0]
	min_ant = min
	min_new = pixel_color[0]
	if (max_new >= max_ant):
	max = max_new
	elif (min_new <= min_ant):
	min = min_new
	elif (min == 0 and max == 255):
	break
	for a in range(x):
	for b in range(y):
	pixel_color = pixeles[a, b]
	try:
	nuevo_pixel = ( float(pixel_color[0]) - float(min) )*( float(255) / (float(max) - float(min)) )
	nuevo_pixel = int(floor(nuevo_pixel))
	except:
	nuevo_pixel = 255
	tupla_promedio = (nuevo_pixel, nuevo_pixel, nuevo_pixel)
	imagen_nueva.putpixel((a, b), tupla_promedio)
	return imagen_nueva
	def cambiar_umbral(imagen, umbral_valor):
	pixeles = imagen.load()
	x, y = imagen.size
	imagen_nueva = Image.new("RGB", (x, y))
	for a in range(x):
	for b in range(y):
	pixel_color = pixeles[a, b]
	valor_canal = float(pixel_color[0])
	color_nor = valor_canal/255.0
	if(color_nor > umbral_valor):
	poner_pixel = 255
	else:
	poner_pixel = 0
	tupla_pixel = (poner_pixel, poner_pixel, poner_pixel)
	imagen_nueva.putpixel((a, b), tupla_pixel)
	return imagen_nueva
	def mediana(arreglo):
	if len(arreglo) % 2 == 1:
	return arreglo[(len(arreglo)+1)/2-1]
	else:
	izq = arreglo[len(arreglo)/2-1]
	der = arreglo[len(arreglo)/2]
	return (float(izq + izq)) / 2.0
	def obtener_original(path_imagen_original):
	imagen = Image.open(path_imagen_original)
	return imagen
	def boton_bordes():
	label.destroy()
	#Pongo a grises
	imagen_grises = cambiar_agrises(path_imagen_original)
	imagen_grises.save("paso_1.jpg")
	#Agrego diferencia
	imagen_prom = diferencia(imagen_grises.convert("RGB"))
	imagen_prom.save("paso_2.jpg")
	#Agrego normalizacion
	imagen_nor = normalizacion(imagen_prom)
	imagen_nor.save("paso_3.jpg")
	#Agrego umbral para binarizar
	umbral_valor = 0.001
	imagen_bin = cambiar_umbral(imagen_nor.convert("RGB"), umbral_valor)
	imagen_bin.save("paso_4.jpg")
	#Pongo promedio
	imagen_prom = cambiar_promedio(imagen_bin.convert("RGB"))
	imagen_prom.save("paso_5.jpg")
	#Agrego umbral para binarizar
	umbral_valor = 0.001
	imagen_bin2 = cambiar_umbral(imagen_prom.convert("RGB"), umbral_valor)
	imagen_bin2.save("paso_6.jpg")
	#####
	#Pongo promedio
	imagen_prom = cambiar_promedio(imagen_bin2.convert("RGB"))
	imagen_prom.save("paso_7.jpg")
	#Pongo promedio
	imagen_prom = cambiar_promedio(imagen_prom.convert("RGB"))
	imagen_prom.save("paso_8.jpg")
	#Agrego umbral para binarizar
	umbral_valor = 0.001
	imagen_BFS = cambiar_umbral(imagen_prom.convert("RGB"), umbral_valor)
	imagen_BFS.save("paso_9.jpg")
	aplicar_BFS(imagen_bin2)
	def aplicar_gift(coordenadas):
	y = []
	x = []
	for i in range(len(coordenadas)):
	x.append(coordenadas[i][0])
	y.append(coordenadas[i][1])
	p0 = min(coordenadas)
	hull = [p0]
	cont = 0
	while 1:
	fin = coordenadas[0]
	for k in range(len(coordenadas) - 1):
	direccion = cmp(0, (hull[cont][0] - coordenadas[k][0])*(fin[1] - coordenadas[k][1]) - (fin[0] - coordenadas[k][0])*(hull[cont][1] - coordenadas[k][1]))
	if fin == hull[cont] or direccion == -1:
	fin = coordenadas[k]
	cont += 1
	hull.append(fin)
	if fin == hull[0]:
	break
	return hull
	def aplicar_BFS(imagen_BFS):
	bordes = []
	pixeles = imagen_BFS.load()
	x, y = imagen_BFS.size
	colores = []
	for a in range(x):
	for b in range(y):
	if pixeles[a, b] == (255, 255, 255):
	color = (random.randint(0,255), random.randint(0,255), random.randint(0, 255))
	imagen_BFS, masa, pixeles_BFS = BFS(imagen_BFS.convert("RGB"), (a, b), color)
	bordes.append(pixeles_BFS)
	x_suma = 0
	y_suma = 0
	for i in range(len(masa)):
	x_suma = x_suma + masa[i][0]
	y_suma = y_suma + masa[i][1]
	x_centro = x_suma/len(masa)
	y_centro = y_suma/len(masa)
	colores.append([color, 0, (x_centro, y_centro)])
	pixeles = imagen_BFS.load()
	masa = []
	pixeles = imagen_BFS.load()
	for a in range(x):
	for b in range(y):
	for n in range(len(colores)):
	if colores[n][0] == pixeles[a,b]:
	colores[n][1] = colores[n][1] + 1
	suma = 0
	for i in range(len(colores)):
	suma = suma + colores[i][1]
	global frame
	y = frame.winfo_height()
	prom = []
	for i in range(len(colores)):
	promedio = float(colores[i][1])/float(suma)*100.0
	if promedio > 3.0:
	print "Porcentajes: "
	print "Figura " + str(i) + ": " + str(promedio)
	prom.append((i, promedio, colores[i][0]))
	maxim = 0.0
	for i in range(len(prom)):
	if maxim < prom[i][1]:
	maxim = prom[i][1]
	fig = prom[i][0]
	color_max = prom[i][2]
	print "Fondo fig: " + str(fig)
	imagen_BFS = pinta_fondo(imagen_BFS, color_max)
	#poner_imagen(imagen_BFS)
	imagen_BFS.save("paso_10.jpg")
	for i in range(len(colores)):
	promedio = float(colores[i][1])/float(suma)*100.0
	if promedio > 1.5:
	print "Identifico . . ."
	label_fig = Label(text = str(i))
	label_fig.place(x = colores[i][2][0], y = colores[i][2][1] + y)
	todos_hull = []
	for i in range(len(bordes)):
	hull = aplicar_gift(bordes[i])
	todos_hull.append(hull)
	draw = ImageDraw.Draw(imagen_BFS)
	for i in range(len(todos_hull)):
	for j in range(len(todos_hull[i])):
	try:
	linea = (todos_hull[i][j][0],todos_hull[i][j][1], todos_hull[i][j+1][0],todos_hull[i][j+1][1])
	except:
	break
	draw.line(linea, fill=128)
	imagen_BFS.save("paso_11.jpg")
	poner_imagen(imagen_BFS)
	print todos_hull
	def pinta_fondo(imagen_BFS, color_max):
	pixeles = imagen_BFS.load()
	x, y = imagen_BFS.size
	for a in range(x):
	for b in range(y):
	if pixeles[a, b] == color_max:
	color = (100,100,100)
	imagen_BFS, masa, bordes = BFS(imagen_BFS.convert("RGB"), (a, b), color)
	return imagen_BFS
	def boton_original():
	label.destroy()
	global imagen_original
	imagen_original = obtener_original(path_imagen_original)
	poner_imagen(imagen_original)
	path_imagen_original = "elefante.jpg"
	imagen_original = obtener_original(path_imagen_original)
	ventana()

view raw convex.py hosted with ❤ by GitHub

Las partes importantes se encientan en BFS y en aplicar_gift

Assignment 2: Experiment for KMP & BM

For homework in the subject Information Theory, we need to do un experiment to check how is the performance between different algorithms that can search in a text, different patterns.

For do this experiment I made both algorithms in Python, then I put a sub procedure that repeat 30 times, change the value for how long are the pattern, the text and the amount of letters that we use to choose for have different prospective about how the algorithm works, it is important to know that for do the patters I use a function that do string random and also create a pattern randomly.

First at all, the following image you can see a map color where we can find 3 different values plotted, how long is the pattern, how long is the text that we check with the pattern and, finally I put a variable that checks the time that the computer wait for do the search, then when the algorithm finish I return this value and I used for have an estimation with the time.

In this image, you can see that if we have a pattern that are just for 1 to 4 letters, we have an algorithm that can do the search and in a time (that is plot in color) and there is a point that have the color almost red, which means that we have problems with the time to do the search of the pattern, but is just in some search, because in the following map of the next algorithm BM, we have more stress but down for the medium.

In this other map, we have that there is not stress as the another algorithm, because we do not have points where the time are up of the medium, but we have more points in purple, which means that we have a lot stress and up for medium.

This is another test, when we can see that BM algorithm is more purple, so, takes more time to search the words.

This is the code:

	import random
	import string
	import time
	def genera_str(tam, lista):
	return ''.join(random.choice(lista) for x in range(tam))
	def algoritmo_KMP(texto, patron):
	inicio = time.time()
	tam_texto = len(texto)
	tam_patron = len(patron)
	M = 0
	index = 0
	if (tam_texto >= tam_patron):
	tabla = []
	for i in range(tam_patron):
	tabla.append(0)
	cont = 0
	for i in range(1, tam_patron):
	while cont > 0 and patron[i] != patron[cont]:
	cont = tabla[cont - 1]
	if patron[i] == patron[cont]:
	cont += 1
	tabla[i] = cont
	tabla.insert(0, -1)
	Tfallos = tabla[:-1]
	while ((index <= tam_patron) and (M < tam_texto)):
	if (texto[M+index] == patron[index]):
	if (index == (tam_patron - 1)):
	fin = time.time()
	tiempo = fin - inicio
	return M, tiempo
	index += 1
	else:
	M = M + index - Tfallos[index]
	if (index > 0):
	index = Tfallos[index]
	def algoritmo_BM(texto, patron):
	inicio = time.time()
	tam_patron = len(patron)
	tam_texto = len(texto)
	mapa = {}
	for i in range(tam_patron-1, -1, -1):
	inter = patron[i]
	if (inter not in mapa):
	mapa[inter] = i
	iguales = []
	cabecera = 0
	while cabecera + (tam_patron - 1) < tam_texto:
	for i_patron in range(tam_patron-1, -1, -1):
	i_lista = cabecera + i_patron
	cor_y = patron[i_patron]
	cor_x = texto[i_lista]
	if i_lista >= tam_texto:
	break
	if cor_y != cor_x:
	derecho = mapa.get(cor_x)
	if cor_x not in mapa:
	cabecera = i_lista + 1
	else:
	recorro = i_lista - (cabecera + derecho)
	cabecera += (recorro > 0 and recorro or cabecera + 1)
	break
	elif i_patron == 0:
	fin = time.time()
	tiempo = fin - inicio
	return cabecera, tiempo
	def experimento(tam_cadena):
	cadena = []
	for i in range(tam_cadena):
	letra = random.choice(string.ascii_uppercase)
	cadena.append(letra)
	for tam_texto in range(10, 1000, 10):
	for tam_patron in range(1,10):
	for i in range(1,30):
	main(tam_texto, tam_patron, cadena)
	def main(tam_1, tam_2, letras):
	T = genera_str(tam_1, letras)
	P = genera_str(tam_2, letras)
	try:
	num_KMP, tiempo_KMP = algoritmo_KMP(T, P)
	num_BM, tiempo_BM = algoritmo_BM(T, P)
	if num_BM == None and tiempo_BM == None:
	num_BM = 0
	tiempo_BM = 0.0
	if num_KMP == None and tiempo_KMP == None:
	num_KMP = 0
	tiempo_BM = 0.0
	if num_BM != 0:
	num_BM = 1
	if num_KMP != 0:
	num_KMP = 1
	except:
	num_KMP = 0
	num_BM = 0
	tiempo_BM = 0.0
	tiempo_KMP = 0.0
	print "%d %d %f %f %d" % (tam_1, tam_2, tiempo_KMP, tiempo_BM, len(letras),)
	for i in range(1,10):
	experimento(i)

view raw busqueda.py hosted with ❤ by GitHub

Plot in gnuplot

	set grid layerdefault
	set term png
	set title 'KMP'
	set ylabel 'texto'
	set xlabel 'patron'
	set xrange[1:9]
	set label ""
	set output "grafica_2.png"
	set key off
	plot "datos.txt" using 2:1:3 with points palette pt 7 ps 3
	set grid layerdefault
	set term png
	set title 'BM'
	set ylabel 'texto'
	set xlabel 'patron'
	set xrange[1:9]
	set label ""
	set output "grafica_3.png"
	set key off
	plot "datos.txt" using 2:1:4 with points palette pt 7 ps 3

view raw plot.gnu hosted with ❤ by GitHub

Lab 3: Mapa de redes WiFi

Para realizar la actividad de laboratorio numero 3 de la materia de telecomunicaciones se nos pide mapear en base a algunos resultados el acceso a internet.

Para realizar esto utilicé la API de google maps, un pequeño programa en PHP para capturar las latitudes y longitudes de modo que podamos tener la distancia entre ellas y el comando airport -s para la captura de información.

RSSI es el indicador de fuerza de señal de recepción, el cual sirve para medir la potencia que tenemos de una red inalámbrica, entre más alto sea esta cifra, o sea, entre más se acerca a 0, es mucho mejor porque nos encontramos más cerca del router, si es más lejos, entonces el valor es más negativo, en mi caso cuando esta muy cerca (lo cheque en dos redes) lo máximo que alcanzaba es -30 o -25 y lo más lejos que encontré es -80, a partir de este rango fue cómo mapeo la red, es importante recalcar que también interviene, por ejemplo cuan pegadas están las casas y si el block que utilizan es mas grueso, por ejemplo dentro de un cuarto de mi casa, no tenía absolutamente ninguna RSSI ni red WiFi, solo algunas veces pero con un valor -80.

Solamente como referencia el parámetro RSSI, aunque varía por situaciones externas.

Para obtener el RSSI el cual demuestra que tan intenso podemos obtener la señal de red, el comando airport -s nos permite escanear las redes que tenemos a nuestro alrededor y así poder saber que tan cerca estamos de un router, en mis test lo que hice fue buscar la menor cantidad posible de RSSI y la maxima cantidad posible del mismo paramatetro para así calcular un radio aparente y dibujar un circulo, este radio es calculado mediante la función de php.

	<?php
	function distancia($latitud_1, $longitud_1, $latitud_2, $longitud_2) {
	$rad = M_PI / 180;
	$latitud_1 = $latitud_1 * $rad;
	$longitud_1 = $longitud_1 * $rad;
	$latitud_2 = $latitud_2 * $rad;
	$longitud_2 = $longitud_2 * $rad;
	$R = 6372.797;
	$dlat = $latitud_2 - $latitud_1;
	$dlog = $longitud_2 - $longitud_1;
	$A = sin($dlat / 2) * sin($dlat / 2) + cos($latitud_1) * cos($latitud_2) * sin($dlog / 2) * sin($dlog / 2);
	$C = 2 * atan2(sqrt($A), sqrt(1 - $A));
	$km = $R * $C;
	return ($km * 0.621371192);
	}
	echo distancia(25.735559, -100.266703, 25.735419, -100.267038) * 1000
	?>

view raw distancia.php hosted with ❤ by GitHub

De esta manera, dada mi ubicación obteniendola desde la api de google maps y capturando los datos obtenidos del comando airport fui guardandolos para luego hacer los radios de los routers.

Luego de obtener los datos, me di cuenta que el área que quería comparar solamente tenía 3 conexiones de red inalámbrica a que comparar, en donde de estas tenía valores que podía graficar y poder hacer los círculos, quedando de la siguiente manera.

aparte de que como algunas latitudes y longitudes dadas  en google maps no eran muy exactas, entonces expandí mi área para tener un más amplio rango, teniendo como resultado.

Para luego dibujar en los puntos más lejanos y las coordenadas que consideraba como centro, teniendo como resultado que por ejemplo mi red infinitud tiene más alcance que las redes de intercable, donde su router solamente marcaba un poco espacio de rango.

Para saber como hice este mapa, pueden descargar mi html aquí.

Expongo mi código html.

	<html>
	<head>
	<meta name="viewport" content="initial-scale=1.0, user-scalable=no">
	<meta charset="utf-8">
	<title>Redes WiFi</title>
	<link href="estilo.css" rel="stylesheet">
	<script src="https://maps.googleapis.com/maps/api/js?v=3.exp&sensor=false"></script>
	<script>
	var map;
	var posicion1 = new google.maps.LatLng(25.735402,-100.267126);
	var posicion2 = new google.maps.LatLng(25.735404,-100.26702);
	var posicion3 = new google.maps.LatLng(25.735597,-100.26674);
	var posicion4 = new google.maps.LatLng(25.73553,-100.266728);
	var posicion5 = new google.maps.LatLng(25.73557,-100.266728);
	var posicion6 = new google.maps.LatLng(25.735371,-100.266973);
	function initialize() {
	var mapOptions = {
	center: posicion1,
	zoom: 20,
	mapTypeId: google.maps.MapTypeId.ROADMAP
	};
	var el = document.getElementById("map_canvas");
	map = new google.maps.Map(el, mapOptions);
	var recorrido1 = new google.maps.Marker({
	map: map,
	position: posicion1,
	title: "{ [ INFINITUM530E, -61 ], [ Superman, -79 ], [ INFINITUMA67AA4, -82 ], [ VIRUS, -83 ] }"
	});
	var recorrido2 = new google.maps.Marker({
	map: map,
	position: posicion2,
	title: "{ [INFINITUM530E, -32], [INFINITUMA67AA4, -82], [VIRUS, -83], [Superman, -53] }"
	});
	var recorrido3 = new google.maps.Marker({
	map: map,
	position: posicion3,
	title: "{[INFINITUM530E, -81],[InterCable9040, -77],[INFINITUM3C0D, -76],[INFINITUMB00E, -70],[INFINITUMEA0E, -76]}"
	});
	var recorrido4 = new google.maps.Marker({
	map: map,
	position: posicion4,
	title: "{[INFINITUM530E -53][INFINITUMB00E -76][Superman -74][InterCable9040 -49][INFINITUM3C0D -52]}"
	});
	var recorrido1_coordenadas = [
	posicion1,
	posicion2
	];
	var recorrido2_coordenadas = [
	posicion2,
	posicion3
	];
	var recorrido3_coordenadas = [
	posicion3,
	posicion4
	];
	var recorrido4_coordenadas = [
	posicion4,
	posicion1
	];
	var lineSymbol = {
	path: 'M 0,-1 0,1',
	strokeOpacity: 1,
	scale: 4
	};
	var line_1 = new google.maps.Polyline({
	path: recorrido1_coordenadas,
	strokeOpacity: 0,
	icons: [{
	icon: lineSymbol,
	offset: '0',
	repeat: '20px'
	}],
	map: map
	});
	var line_2 = new google.maps.Polyline({
	path: recorrido2_coordenadas,
	strokeOpacity: 0,
	icons: [{
	icon: lineSymbol,
	offset: '0',
	repeat: '20px'
	}],
	map: map
	});
	var line_3 = new google.maps.Polyline({
	path: recorrido3_coordenadas,
	strokeOpacity: 0,
	icons: [{
	icon: lineSymbol,
	offset: '0',
	repeat: '20px'
	}],
	map: map
	});
	var line_4 = new google.maps.Polyline({
	path: recorrido4_coordenadas,
	strokeOpacity: 0,
	icons: [{
	icon: lineSymbol,
	offset: '0',
	repeat: '20px'
	}],
	map: map
	});
	var Red1 = {
	strokeColor: "#FE2EC8",
	strokeOpacity: 0.8,
	strokeWeight: 2,
	fillColor: "#FE2EC8",
	fillOpacity: 0.1,
	map: map,
	center: posicion1,
	radius: 13
	};
	var Red2 = {
	strokeColor: "#B40404",
	strokeOpacity: 0.8,
	strokeWeight: 2,
	fillColor: "#B40404",
	fillOpacity: 0.35,
	map: map,
	center: posicion2,
	radius: 15
	};
	var Red3 = {
	strokeColor: "#4000FF",
	strokeOpacity: 0.8,
	strokeWeight: 2,
	fillColor: "#4000FF",
	fillOpacity: 0.35,
	map: map,
	center: posicion5,
	radius: 12
	};
	var Red4 = {
	strokeColor: "#A5DF00",
	strokeOpacity: 0.8,
	strokeWeight: 2,
	fillColor: "#A5DF00",
	fillOpacity: 0.35,
	map: map,
	center: posicion4,
	radius: 10
	};
	var Red5 = {
	strokeColor: "#0B4C5F",
	strokeOpacity: 0.8,
	strokeWeight: 2,
	fillColor: "#0B4C5F",
	fillOpacity: 0.35,
	map: map,
	center: posicion6,
	radius: 17
	};
	Red1 = new google.maps.Circle(Red1);
	Red2 = new google.maps.Circle(Red2);
	Red3 = new google.maps.Circle(Red3);
	Red4 = new google.maps.Circle(Red4);
	Red5 = new google.maps.Circle(Red5);
	}
	initialize();
	</script>
	</head>
	<body onload="initialize()">
	<div id="map_canvas"></div>
	</body>
	</html>

view raw hola.html hosted with ❤ by GitHub

Lab 3: Técnicas para el diseño de cómputo sensible al contexto

Para el laboratorio 3 de la materia de temas selectos de sistemas inteligentes, se nos pide realizar un reporte en donde hablemos acerca de diferentes técnicas que podemos utilizar para recabar información, estudiar el contexto, definir usuarios y objetivos importantes a la hora de realizar un producto en donde tengamos que tomar en cuenta diferentes aspectos, no simplemente como proyecto para que si queremos tener éxito en algún producto, hacer un análisis de la parte más importante de su desarrollo, el cual es el diseño, en este caso enfocado al contexto.

Para esta entrada tomé algunas técnicas que considero importantes a la hora de diseñar un producto, las cuales ya hemos utilizando en diferentes clases a lo largo de nuestra carrera y que podemos utilizar algunas de ellas para hacer un estudio importante a la hora de modelar un proyecto, entre ellos puedo distinguir.

• Análisis del entorno industrial
• Recabar información de usuarios objetivo
• Definición de personas y escenarios
• Recorrido cognitivo

Análisis del entorno industrial.

Como hemos hecho en esta materia, podemos hacer una revisión de trabajos relacionados de manera que tengamos un campo de perspectiva a lo que queremos desarrollar y lo que ya existe en el mercado, es importante hacer esta revisión ya que nos damos cuenta del panorama actual en la industria y tener como objetivo cierta carencia que los demás productos tienen para innovar desde ahí y atacar los puntos débiles de otros proyecto, obteniendo un resultado prometedor en cuestión a la competencia.

Entre los puntos que debemos considerar al realizar un estudio de los trabajos relacionados con nuestro proyecto sería el hecho de las características, su tamaño físico y si ya se encuentra como un producto existente o es emergente en el mercado, de manera que podamos observar como es campo actualmente y como queremos llegar a contribuir a ese campo con un nuevo producto que supere a la competencia.

Se pueden realizar, como hemos hecho anteriormente, una matriz en donde por medio de colores podamos identificar las características de cada producto y ver que es lo que podemos proponer y como contra atacar esos productos para tener uno que sea mejor que los demás.

Podemos encontrar más información acerca de cómo empezar a realizar un prototipo en base a al análisis del entorno en el siguiente documento de la página entrepeneur la cual nos da algunos tips para mejorar el prototipo de algún producto. liga.

También encontré un recurso importante en donde podemos en base nuestro análisis poder realizar un resumen de las características que queremos en nuestro diseño, con la plantilla que utiliza el Instituto de Arquitectura. liga.

Recabar información de usuarios objetivo.


Al momento de hacer un estudio de los trabajos relacionados, podemos ahora proseguir a recabar información de usuarios a los que nosotros queremos atraer en utilizar un producto por lo que se pueden realizar diferentes encuestas en donde podamos tener la mayor cantidad posible de información de una muestra de personas que pudieran ayudar al desarrollo de un prototipo, preguntas clave que demuestren que es lo que el usuario objetivo necesita y si nosotros podemos ayudar a que esas necesidades de cumplan.

Esto no solamente es el hacer una encuesta, si no que podemos realizar diferentes estudios como por ejemplo el hecho de grabar a una persona en su vida diaria para saber como actúa frente a los productos del competidor y que queremos mejorar en como actúa sobre estos, realizar este tipo de estudios con diferentes usuarios puede ayudar a obtener un campo más amplio de lo que queremos desarrollar.


Para más información de como seleccionar a un usuario ideal, podemos ver el siguiente documento. liga. en donde nos ayudan a seleccionar al usuario no solamente suponiendo lo que pensamos que esta bien si no con una serie de ideas para llegar al objetivo.

En la siguiente liga, podemos encontrar herramientas que son utiles para contabilizar y enumerar la experiencia de uso de un producto, de manera que podamos elegir un mejor objetivo.


Definición de personas y escenarios.


Para definir las personas y cómo estas van a utilizar este producto, debemos de crear en base a lo que obtuvimos de información anteriormente una lista de personas las cuales pueden utilizar un producto que queremos desarrollar, para luego crear un ambiente de escenario de en cómo puede esta persona utilizar dicho producto.

Se hace un ejemplo ilustrativo del escenario que podría pasar un usuario al momento de adquirir un producto, por lo que obtenemos una serie de historias que son hipotéticas pero ayudar a la comprensión de lo que se desea hacer y a donde se quiere llegar.

Los arquetipos, otra manera de llamar a las personas y escenarios, son útiles para entender el entorno, podemos encontrar más información de como elegirlos y describir correctamente a estos en las siguientes diapositivas. liga.

Recorrido cognitivo.


Luego de tener un prototipo en el cual podemos hacer pruebas de usuario, podemos hacer un recorrido cognitivo basado en los escenarios y personas que hemos dictado anteriormente, en donde vamos a obtener más información de como el usuario enfrenta una situación con el producto directamente obteniendo resultados importantes para mejorar el prototipo e iterar hasta que tengamos respuestas favorables en la mayoría de las pruebas.

Es importante recalcar que un recorrido cognitivo no solamente se hace en interfaces web, si no que sirve para entender cómo la persona actúa en una situación común.

Algunos ejemplo de recorridos cognitivos simples.

El uso de un ATM.

Ciclos de diseño.
Como en ingeniería de software, no existe un método que sea completamente eficiente para todo tipo de proyectos, es lo mismo que en la ingeniería de diseño en general, por lo que en los siguientes videos, podemos ver una clase en el cual nos dan ideas de que podemos realizar para mejorar y desarrollar el diseño, básicamente es lo mismo que he explicando anteriormente pero algunos con más profundidad o con otros nombres.

Espero que la información dada ayude a entender el complejo mundo de el diseño y que técnicas son útiles y básicas para mejorar nuestro idea.

Tarea 2: Identificación de figuras

Para la tarea dos de la materia de Visión Computacional, se nos pide hacer un programa en donde identifiquemos los objetos, al igual que poner etiquetas y detectar el fondo de alguna imagen, por lo que para realizar este programa, utilizo la manera de detectar los bordes como lo hicimos en el laboratorio anterior en donde obtengo la diferencia del promedio y sacar el cambio para poder después binarizar y obtener una imagen con bordes definidos.

Para esta parte de la tarea es agregar primero que nada que los contornos sean definidos y continuos, por lo que estuve trabajando para mejorar mi código anterior y obtener unos mejores contornos, hice varias veces el promedio y la binarización para hacerlos más anchos y así no tener problemas de continuidad.

Ahora después de tener los contornos marcados y continuos, realicé una subrutina que hace una búsqueda en anchura para ir determinando los pixeles vecinos y saber si pertenecen a una figura o no, al momento de ir rellenando las figuras, vamos descartando aquellas que se encuentren con pixeles negros, siendo solamente objetos que van a procesarse para obtener figuras completas y de ahí sacar sus datos importantes.

Luego de obtener las diferentes figuras, calculamos su centro de masa, esto simplemente checando sus coordenadas para después dividirlos entre el total y colocándolos dentro de la ventana.

También detecto el fondo de manera que cambie de color gris, este simplemente calculo el porcentaje de color de cada figura y obtengo el más grande asegurando que es el fondo, para luego proceder en cambiar su color a gris.

Para obtener bordes más definidos, vario los valores de umbral para la binarización, por lo que obtenemos imágenes con bordes resultados y sin tanto ruido, como podemos ver en esta imagen la cual es la misma que la anterior pero con valores umbral diferentes.

Ahora muestro capturas de pantalla de algunas imágenes que verifique.

A continuación muestro el código, en donde las funciones relevantes son BFS, aplicar_BFS, pintar_fondo.

	from Tkinter import *
	from PIL import Image, ImageTk
	from math import floor
	import numpy
	import random
	def ventana():
	root = Tk()
	root.title('Tarea 2')
	global frame
	frame = Frame()
	frame.pack(padx=5,pady=5)
	poner_imagen(obtener_original(path_imagen_original))
	b1 = Button(text='Original', command = boton_original).pack(in_=frame, side=LEFT)
	b4 = Button(text='Identificar', command = boton_bordes).pack(in_=frame, side=LEFT)
	root.mainloop()
	def poner_imagen(image):
	photo = ImageTk.PhotoImage(image)
	global label
	label = Label(image=photo)
	label.imagen = photo
	label.pack()
	def BFS(imagen, inicio, color):
	#Busqueda de anchura para determinar una figura
	pixeles = imagen.load()
	altura, ancho = imagen.size
	fila, columna = inicio
	original = pixeles[fila, columna]
	cola = []
	cola.append((fila, columna))
	masa = []
	while len(cola) > 0:
	(fila, columna) = cola.pop(0)
	actual = pixeles[fila, columna]
	if actual == original or actual == color:
	for dx in [-1, 0, 1]:
	for dy in [-1, 0, 1]:
	candidato = (fila + dy, columna + dx)
	if candidato[0] >= 0 and candidato[0] < altura and candidato[1] >= 0 and candidato[1] < ancho:
	contenido = pixeles[candidato[0], candidato[1]]
	if contenido == original:
	pixeles[candidato[0], candidato[1]] = color
	imagen.putpixel((candidato[0], candidato[1]), color)
	cola.append(candidato)
	masa.append((candidato[0], candidato[1]))
	return imagen, masa
	def cambiar_agrises(path_original):
	imagen = Image.open(path_imagen_original).convert("RGB")
	pixeles = imagen.load()
	x, y = imagen.size
	imagen_nueva = Image.new("RGB", (x, y))
	colores = []
	for a in range(x):
	for b in range(y):
	pixel_color = pixeles[a, b]
	promedio = sum(pixel_color)/3
	tupla_promedio = (promedio, promedio, promedio)
	colores.append(tupla_promedio)
	imagen_nueva.putpixel((a, b), tupla_promedio)
	return imagen_nueva
	def cambiar_promedio(imagen):
	pixeles = imagen.load()
	x, y = imagen.size
	imagen_nueva_prom = Image.new("RGB", (x, y))
	colores = []
	for a in range(x):
	for b in range(y):
	pixel_color = pixeles[a, b]
	veces = 5
	suma = 0
	promedio = 0
	try:
	pixel_norte = pixeles[a-1,b]
	except IndexError:
	pixel_norte = (0, 0, 0)
	veces = veces - 1
	try:
	pixel_sur = pixeles[a+1, b]
	except IndexError:
	pixel_sur = (0, 0, 0)
	veces = veces - 1
	try:
	pixel_este = pixeles[a, b+1]
	except IndexError:
	pixel_este = (0, 0, 0)
	veces = veces - 1
	try:
	pixel_oeste = pixeles[a, b-1]
	except IndexError:
	pixel_oeste = (0, 0, 0)
	veces = veces - 1
	Rojos_suma = pixel_norte[0] + pixel_sur[0] + pixel_este[0] + pixel_oeste[0] + pixel_color[0]
	Verdes_suma = pixel_norte[1]+ pixel_sur[1] + pixel_este[1] + pixel_oeste[1] + pixel_color[1]
	Azul_suma = pixel_norte[2]+ pixel_sur[2] + pixel_este[2] + pixel_oeste[2] + pixel_color[2]
	Rojo_prom = Rojos_suma/veces
	Verdes_prom = Verdes_suma/veces
	Azul_prom = Azul_suma/veces
	tupla_promedio = (Rojo_prom, Verdes_prom, Azul_prom)
	colores.append(tupla_promedio)
	imagen_nueva_prom.putpixel((a, b), tupla_promedio)
	return imagen_nueva_prom
	def diferencia(imagen):
	pixeles = imagen.load()
	x, y = imagen.size
	imagen_nueva_prom = Image.new("RGB", (x, y))
	colores = []
	for a in range(x):
	for b in range(y):
	pixel_color = pixeles[a, b]
	veces = 5
	suma = 0
	promedio = 0
	try:
	pixel_norte = pixeles[a-1,b]
	except IndexError:
	pixel_norte = (0, 0, 0)
	veces = veces - 1
	try:
	pixel_sur = pixeles[a+1, b]
	except IndexError:
	pixel_sur = (0, 0, 0)
	veces =veces - 1
	try:
	pixel_este = pixeles[a, b+1]
	except IndexError:
	pixel_este = (0, 0, 0)
	veces =veces - 1
	try:
	pixel_oeste = pixeles[a, b-1]
	except IndexError:
	pixel_oeste = (0, 0, 0)
	veces =veces - 1
	Rojos_suma = pixel_norte[0] + pixel_sur[0] + pixel_este[0] + pixel_oeste[0] + pixel_color[0]
	Verdes_suma = pixel_norte[1]+ pixel_sur[1] + pixel_este[1] + pixel_oeste[1] + pixel_color[1]
	Azul_suma = pixel_norte[2]+ pixel_sur[2] + pixel_este[2] + pixel_oeste[2] + pixel_color[2]
	Rojo_prom = Rojos_suma/veces
	Verde_prom = Verdes_suma/veces
	Azul_prom = Azul_suma/veces
	Rojo_dif = pixel_color[0] - Rojo_prom
	Verde_dif = pixel_color[1] - Verde_prom
	Azul_dif = pixel_color[2] - Azul_prom
	tupla_promedio = (Rojo_dif, Verde_dif, Azul_dif)
	colores.append(tupla_promedio)
	imagen_nueva_prom.putpixel((a, b), tupla_promedio)
	return imagen_nueva_prom
	def normalizacion(imagen):
	pixeles = imagen.load()
	x, y = imagen.size
	min = 0
	max = 0
	imagen_nueva = Image.new("RGB", (x, y))
	for a in range(x):
	for b in range(y):
	pixel_color = pixeles[a, b]
	max_ant = max
	max_new = pixel_color[0]
	min_ant = min
	min_new = pixel_color[0]
	if (max_new >= max_ant):
	max = max_new
	elif (min_new <= min_ant):
	min = min_new
	elif (min == 0 and max == 255):
	break
	print min
	print max
	for a in range(x):
	for b in range(y):
	pixel_color = pixeles[a, b]
	try:
	nuevo_pixel = ( float(pixel_color[0]) - float(min) )*( float(255) / (float(max) - float(min)) )
	nuevo_pixel = int(floor(nuevo_pixel))
	except:
	nuevo_pixel = 255
	tupla_promedio = (nuevo_pixel, nuevo_pixel, nuevo_pixel)
	imagen_nueva.putpixel((a, b), tupla_promedio)
	return imagen_nueva
	def cambiar_umbral(imagen, umbral_valor):
	pixeles = imagen.load()
	x, y = imagen.size
	imagen_nueva = Image.new("RGB", (x, y))
	for a in range(x):
	for b in range(y):
	pixel_color = pixeles[a, b]
	valor_canal = float(pixel_color[0])
	color_nor = valor_canal/255.0
	if(color_nor > umbral_valor):
	poner_pixel = 255
	else:
	poner_pixel = 0
	tupla_pixel = (poner_pixel, poner_pixel, poner_pixel)
	imagen_nueva.putpixel((a, b), tupla_pixel)
	return imagen_nueva
	def mediana(arreglo):
	if len(arreglo) % 2 == 1:
	return arreglo[(len(arreglo)+1)/2-1]
	else:
	izq = arreglo[len(arreglo)/2-1]
	der = arreglo[len(arreglo)/2]
	return (float(izq + izq)) / 2.0
	def obtener_original(path_imagen_original):
	imagen = Image.open(path_imagen_original)
	return imagen
	def boton_bordes():
	label.destroy()
	#Pongo a grises
	imagen_grises = cambiar_agrises(path_imagen_original)
	imagen_grises.save("paso_1.jpg")
	#Agrego diferencia
	imagen_prom = diferencia(imagen_grises.convert("RGB"))
	imagen_prom.save("paso_2.jpg")
	#Agrego normalizacion
	imagen_nor = normalizacion(imagen_prom)
	imagen_nor.save("paso_3.jpg")
	#Agrego umbral para binarizar
	umbral_valor = 0.1
	imagen_bin = cambiar_umbral(imagen_nor.convert("RGB"), umbral_valor)
	imagen_bin.save("paso_4.jpg")
	#Pongo promedio
	imagen_prom = cambiar_promedio(imagen_bin.convert("RGB"))
	imagen_prom.save("paso_5.jpg")
	#Agrego umbral para binarizar
	umbral_valor = 0.08
	imagen_bin2 = cambiar_umbral(imagen_prom.convert("RGB"), umbral_valor)
	imagen_bin2.save("paso_6.jpg")
	#####
	#Pongo promedio
	imagen_prom = cambiar_promedio(imagen_bin2.convert("RGB"))
	imagen_prom.save("paso_7.jpg")
	#Pongo promedio
	imagen_prom = cambiar_promedio(imagen_prom.convert("RGB"))
	imagen_prom.save("paso_8.jpg")
	#Agrego umbral para binarizar
	umbral_valor = 0.5
	imagen_BFS = cambiar_umbral(imagen_prom.convert("RGB"), umbral_valor)
	imagen_BFS.save("paso_9.jpg")
	aplicar_BFS(imagen_BFS)
	def aplicar_BFS(imagen_BFS):
	#aplica busqueda de anchura a todas las figuras encontradas con color aleatorio
	pixeles = imagen_BFS.load()
	x, y = imagen_BFS.size
	colores = []
	for a in range(x):
	for b in range(y):
	if pixeles[a, b] == (0, 0, 0):
	color = (random.randint(0,255), random.randint(0,255), random.randint(0, 255))
	imagen_BFS, masa = BFS(imagen_BFS.convert("RGB"), (a, b), color)
	x_suma = 0
	y_suma = 0
	for i in range(len(masa)):
	x_suma = x_suma + masa[i][0]
	y_suma = y_suma + masa[i][1]
	x_centro = x_suma/len(masa)
	y_centro = y_suma/len(masa)
	colores.append([color, 0, (x_centro, y_centro)])
	pixeles = imagen_BFS.load()
	masa = []
	#suma la cantidad de colores diferentes en la imagen
	pixeles = imagen_BFS.load()
	for a in range(x):
	for b in range(y):
	for n in range(len(colores)):
	if colores[n][0] == pixeles[a,b]:
	colores[n][1] = colores[n][1] + 1
	print colores
	suma = 0
	for i in range(len(colores)):
	suma = suma + colores[i][1]
	global frame
	y = frame.winfo_height()
	#Obtenemos porcentajes
	prom = []
	for i in range(len(colores)):
	promedio = float(colores[i][1])/float(suma)*100.0
	if promedio > 3.0:
	print "Porcentajes: "
	print "Figura " + str(i) + ": " + str(promedio)
	prom.append((i, promedio, colores[i][0]))
	maxim = 0.0
	for i in range(len(prom)):
	if maxim < prom[i][1]:
	maxim = prom[i][1]
	fig = prom[i][0]
	color_max = prom[i][2]
	#Itentificamos fondo y lo pintamos a gris
	print "Fondo fig: " + str(fig)
	imagen_BFS = pinta_fondo(imagen_BFS, color_max)
	poner_imagen(imagen_BFS)
	#Agregamos etiquetas segun su centro de masa
	for i in range(len(colores)):
	promedio = float(colores[i][1])/float(suma)*100.0
	if promedio > 1.5:
	print "Identifico . . ."
	label_fig = Label(text = str(i))
	label_fig.place(x = colores[i][2][0], y = colores[i][2][1] + y)
	def pinta_fondo(imagen_BFS, color_max):
	#pintamos fondo de manera que obtenemos el color que predomina en la imagen
	pixeles = imagen_BFS.load()
	x, y = imagen_BFS.size
	for a in range(x):
	for b in range(y):
	if pixeles[a, b] == color_max:
	color = (100,100,100)
	imagen_BFS, masa = BFS(imagen_BFS.convert("RGB"), (a, b), color)
	return imagen_BFS
	def boton_original():
	label.destroy()
	global imagen_original
	imagen_original = obtener_original(path_imagen_original)
	poner_imagen(imagen_original)
	path_imagen_original = "figuras2.jpg"
	imagen_original = obtener_original(path_imagen_original)
	ventana()

view raw identificar.py hosted with ❤ by GitHub

Esta sería mi tarea 2 de visión computacional, si tienen alguna duda, favor de hacérmelo saber.