Laboratorio 4

Para esta entrega se nos pidió realizar la detección de líneas diagonales.

Código:

	#Convolucion
	im = Image.open("escala.jpg")
	pix = im.load()
	dirX = ([-1, 0, 1], [-2, 0, 2], [-1, 0, 1])
	dirY = ([1, 2, 1], [0, 0, 0], [-1, -2, -1])
	for x in range(0,ancho-3): #Ancho
	for y in range(0,largo-3): #Largo
	sumDirX=0
	sumDirY=0
	for i in range(0,3):
	for j in range(0,3):
	sumDirX +=(pix[x+i,y+j][0]*dirX[i][j])
	sumDirY +=(pix[x+i,y+j][0]*dirY[i][j])
	potX = pow(sumDirX, 2)
	potY = pow(sumDirY, 2)
	res = int(math.sqrt(potX+potY))
	if res > 255:
	res = 255
	if res < 0:
	res = 0
	pix[x,y] = (res, res, res)
	im.save("convolucion.jpg")
	imagen=pygame.image.load("convolucion.jpg")
	ventana.blit(imagen,(0,0))
	pygame.display.update()
	#Lineas
	CERO = 0.00001
	gx = dirX
	gy = dirY
	for x in range(ancho):
	rhos.append([])
	ang.append([])
	magn.append([])
	for i in range(len(vecinosOrdenados)): # multiplicaciones de matrices
	gx = (vecinosOrdenados[i] * mascaraX[i]) + gx
	gy = (vecinosOrdenados[i] * mascaraY[i]) + gy
	angulo = 0.0
	if gx > 0.0 and gy == 0.0: # 0
	elegidos.append((indice, rojo))
	angulo = 0.0
	elif gx < 0.0 and gy == 0.0: # 180
	elegidos.append((indice, rojo))
	angulo = 180.0
	if gx == 0.0 and gy > 0.0: # 90
	elegidos.append((indice, azul))
	angulo = 90.0
	elif gx == 0.0 and gy < 0.0: # 270
	elegidos.append((indice, azul))
	angulo = 270.0
	elif gx * gy != 0.0: # cualquier otro
	elegidos.append((indice, verde))
	angulo = math.atan(gy / gx)
	im.save("lineas.jpg")
	imagen=pygame.image.load("lineas.jpg")
	ventana.blit(imagen,(0,0))
	pygame.display.update()

view raw diagonales.py hosted with ❤ by GitHub

Laboratorio 4

Bloqueo de PC.

Me parece una gran idea, ya que muchos dejan su computadora con sesiones abiertas y pueden robar archivos o información privada.

En cuanto a la idea de utilizar reconocimiento tal vez convendría agregar otro dispositivo que genere códigos o algún dispositivo con algún sensor (bluetooth o algún otro) que si detecta que estas dentro del rango de la computadora no se bloquee, para hacerlo más seguro, ya que si utilizan reconocimiento de rostro, voz, hay muchas personas que pueden tener un rostro muy parecido (algún familiar) o el mismo tono de voz.

Localizador de personas.

Es un buen proyecto, ya que le serviría a muchos padres de familia a encontrar en sus hijos en caso de que se desaparezcan en algun centro comercial u otro lugar. Un problema podría ser la duración de la batería, hay que pensar de qué tamaño sería el brazalete y si tendrá algún tipo de protección contra el agua o golpes.

Galería Inteligente.

Es una buena idea ya que harían más atractivo los museos o lugares en donde se expongan diferentes tipos de artesanías, pinturas, etc.

Las vitrinas inteligentes y avatares inteligentes son muy buena idea pero creo que la implementación de un celular no sería lo más apropiado para un museo, ya que podrían grabar y publicar videos/imágenes del museo y harían que menos gente asista a estos museos.

Cama Inteligente.

Muchos batallamos para levantarnos y con este tipo de sistema sería más fácil levantarnos.

Debería de poderse agregarle un plan de horario en donde especifiquemos la hora en que debemos levantarnos ya que puede haber días en que tengamos que ir específicamente a una hora ya sea por exámenes/juntas etc; pero el sistema detecto que te quedaban muchas horas de sueño o estabas en un ciclo de sueño profundo y te levanta muy temprano o muy tarde.

Garage Inteligente.

Creo que la apertura mediante proximidad de un RFID tag sería la mejor opción, en cuanto a seguridad.

Tal vez un problema sería si quieres estacionar otro vehículo en tu cochera, ya sea de algún familiar o alguna otra persona.

Tarea 3 Detección de líneas

En esta tarea consiste en la detección de líneas en una imagen, el cual utilizamos la transformada de hough.

Para esto hay que sacar “rho” en cada píxel, esto nos da la dirección que tiene.

Para los gradientes de x y y se utiliza la siguiente ecuación:

Para sacar gradiente en X y Y se utilizó la máscara de sobel, ya que esta ya la habíamos utilizado en una Tarea anterior.

Código:

	#Convolucion
	im = Image.open("escala.jpg")
	pix = im.load()
	dirX = ([-1, 0, 1], [-2, 0, 2], [-1, 0, 1])
	dirY = ([1, 2, 1], [0, 0, 0], [-1, -2, -1])
	for x in range(0,ancho-3): #Ancho
	for y in range(0,largo-3): #Largo
	sumDirX=0
	sumDirY=0
	for i in range(0,3):
	for j in range(0,3):
	sumDirX +=(pix[x+i,y+j][0]*dirX[i][j])
	sumDirY +=(pix[x+i,y+j][0]*dirY[i][j])
	potX = pow(sumDirX, 2)
	potY = pow(sumDirY, 2)
	res = int(math.sqrt(potX+potY))
	if res > 255:
	res = 255
	if res < 0:
	res = 0
	pix[x,y] = (res, res, res)
	im.save("convolucion.jpg")
	imagen=pygame.image.load("convolucion.jpg")
	ventana.blit(imagen,(0,0))
	pygame.display.update()
	#Lineas
	CERO = 0.00001
	gx = dirX
	gy = dirY
	for x in range(ancho):
	rhos.append([])
	ang.append([])
	magn.append([])
	for y in range(largo):
	hor = gx[y][x]
	ver = gy[y][x]
	magnitud = m[y][x]
	if fabs(hor) > CERO:
	angulo = atan(ver / hor) # RELEVANTE
	else:
	if fabs(hor) + fabs(ver) < CERO:
	angulo = None # aqui no hay nada en ninguna direccion
	elif fabs(ver - hor) < CERO: # casi iguales
	angulo = atan(1.0)
	elif hor * ver > 0.0: # mismo signo
	angulo = pi
	else: # negativo -> -pi
	angulo = 0.0
	# eje vertical volteado y origen al centro
	if angulo is not None:
	# asegurar que este entre cero y pi (0 y 180)
	while angulo < CERO:
	angulo += pi
	while angulo > pi:
	angulo -= pi
	rho = (x - ancho/2) * cos(angulo) + (largo/2 - y) * sin(angulo) # RELEVANTE
	# hay que discretizar - RELEVANTE
	magn[x].append(magnitud)
	ang[x].append('%.0f' % (int(180 * (angulo / pi)) / 18))
	rhos[x].append('%.0f' % rho)
	else:
	magn[x].append(None)
	ang[x].append(None)
	rhos[x].append(None)
	im.save("lineas.jpg")
	imagen=pygame.image.load("lineas.jpg")
	ventana.blit(imagen,(0,0))
	pygame.display.update()

view raw Lineas.py hosted with ❤ by GitHub

Resultado: No logre detectar las líneas.

Laboratorio 3

Para esta entrega de laboratorio se nos pidió obtener Convex Hull de una imagen.

Para la realización de esto fue necesario usar el algoritmo utilizado en la Tarea 2:

http://sergio-hdz.blogspot.mx/2013/02/tarea-2.html

Además se necesitaban 2 imágenes con fondo negro y con alguna figura con líneas blancas.

Utilice el algoritmo de Jarvis march el cual se inicia en algún punto extremo del contorno, y en cada paso se prueba cada punto de los puntos y se encuentra cual hace la vuelta más larga hacia la derecha.

Código:

	TURN_LEFT, TURN_RIGHT, TURN_NONE = (1, -1, 0)
	def turn(x, y, z):
	return cmp((y[0] - x[0])*(z[1] - x[1]) - (z[0] - x[0])*(y[1] - x[1]), 0)
	def convex(cor):
	convex_hull = [min(cor)]
	ancho, largo = im.size
	pix = im.load()
	for i in range(len(cor)):
	q = cor[0]
	for j in range(len(cor)):
	t = turn(cor[j], convex[i], q)
	if q == convex[i] or t == TURN_LEFT :
	q = cor[j]
	convex.append(q)
	if q == convexl[0]:
	break
	return convex
	def conve(im):
	im = Image.open("ejem1.jpg")
	pix = im.load()
	hulls = []
	for i in range(ancho):
	for j in range(largo):
	if pix[i, j] == (255, 255, 255):
	inicio, arr= bfs(im, (i, j), (255, 0, 0))
	hulls.append(con(ver))
	for hull in hulls:
	for cor in hull:
	pix[cor] = (0, 255, 0)
	im.save("conv.jpg")
	return hulls
	imagen=pygame.image.load("conv.jpg")
	ventana.blit(imagen,(0,0))
	pygame.display.update()

view raw convhull.py hosted with ❤ by GitHub

Resultado:

Referencias:

http://www.cs.princeton.edu/courses/archive/spr09/cos226/demo/ah/JarvisMarch.html

http://tomswitzer.net/2009/12/jarvis-march/

Repositorio:

https://github.com/Sergiohdz/VisionComputacional

Lab 3

El concepto de evaluación implica la comparación y la toma de decisiones.

La meta de la evaluación es gastar la menor cantidad de recursos en decidir qué conceptos tienen el mayor potencial para convertirse en un producto de calidad, y la dificultar es el elegir el mejor concepto con un conocimiento muy limitado y los datos en los que basar esta selección.

Los elementos comunes en todas las evaluaciones de algún producto son las encuestas y el tipo de evaluación. En la evaluación del producto el concepto son representaciones simples de las ideas de productos en una determinada etapa del proceso de diseño.

El tipo de conceptos que pueden ser utilizados para las evaluaciones de producto son las siguientes:

Conceptos textuales: Descripción de la idea del producto que casi siempre consiste en la descripción de lo que uno puede hacer con la idea del producto. Se puede describir como un escenario de cómo una persona puede utilizar el producto o resumir los aspectos de la idea del producto.

Conceptos Pictográficos: Estas son representaciones visuales de las ideas de productos, el dibujo y la visualización son las más importantes durante el proceso del diseño, dependiendo del proceso de diseño de estas representaciones visuales son visualizaciones altamente detallados o simples representaciones.

Animaciones: Avanzar en las representaciones visuales de la idea del producto. El uso de software gráfico de ordenador se ha convertido en muy fácil de hacer una animación simple de cómo el producto puede utilizarse en un contexto particular.

Mock-ups: Tres dimensiones, representaciones tangibles de la idea del producto. Mock-ups son un tipo de prototipo que sólo muestra las características externas una idea de producto.

La selección de los encuestados es un aspecto importante en las evaluaciones de producto.

Se puede hacer una selección en función de las características socio-culturales o basada en las características demográficas. Los temas importantes a tener en cuenta son el nivel de conocimiento de la categoría de productos que los encuestados tienen. Para evaluar este nivel de conocimiento, uno puede simplemente pedir al entrevistado acerca de sus experiencias con productos similares. Otra cuestión importante a tener en cuenta al seleccionar los encuestados se relaciona con aspectos psicológicos como la tolerancia y la capacidad de innovación. Las preguntas que son importantes son: el grado de tolerancia son los encuestados hacia nuevos productos y nuevas situaciones? Cómo innovador, o conservador, son los encuestados? Tales aspectos psicológicos tienen una gran influencia en los resultados de las evaluaciones de productos conceptuales.

Los diferentes tipos de evaluaciones pueden ser utilizados para las evaluaciones concepto de producto. Uno de los métodos más comunes utilizados en la evaluación del producto es el concepto personal (individual) entrevista. Otra forma puede ser grupos de discusión o grupos de discusión. En los grupos focales, una evaluación concepto del producto se lleva a cabo con un grupo pequeño de personas, y tiene la forma de una discusión en grupo. Evaluación del producto concepto se estructuran de acuerdo a las listas de pre-formuladas con preguntas. 

Bibliografía: http://wikid.eu/index.php/Concept_evaluation

Tarea 2

Para esta entrada se nos pidió:

• Agregar una rutina que detecta todos los componentes conexos separados por bordes.
• El componente más grande debe suponerse ser el fondo, y colorearse gris.
• Los demás dibujos se les asignan colores fuertes. Colocando el borde en blanco y un punto negro en el centro indicando el centro de masa.

Antes de hacer la detección de formas se tiene que pasar la imagen a escala de grises:

Luego aplicar una máscara (convolución):

Y finalmente la binarización de la imagen:

Una vez realizado esto se procede a la detección de formas:

	#Escala de grises
	im = Image.open("ab.jpg")
	pix = im.load()
	for x in range(0,ancho): #Ancho
	for y in range(0,largo): #Largo
	(r,g,b) = pix[x,y]
	promedio=(r+g+b)/3
	pix[x,y] =(promedio,promedio,promedio)
	im.save('escala.jpg')
	imagen=pygame.image.load("escala.jpg")
	ventana.blit(imagen,(0,0))
	pygame.display.update()
	im = Image.open("escala.jpg")
	pix = im.load()
	dirX = ([-1, 0, 1], [-2, 0, 2], [-1, 0, 1])
	dirY = ([1, 2, 1], [0, 0, 0], [-1, -2, -1])
	for x in range(0,ancho-3): #Ancho
	for y in range(0,largo-3): #Largo
	sumDirX=0
	sumDirY=0
	for i in range(0,3):
	for j in range(0,3):
	sumDirX +=(pix[x+i,y+j][0]*dirX[i][j])
	sumDirY +=(pix[x+i,y+j][0]*dirY[i][j])
	potX = pow(sumDirX, 2)
	potY = pow(sumDirY, 2)
	res = int(math.sqrt(potX+potY))
	if res > 255:
	res = 255
	if res < 0:
	res = 0
	pix[x,y] = (res, res, res)
	im.save('convolucion.jpg')
	imagen=pygame.image.load("convolucion.jpg")
	ventana.blit(imagen,(0,0))
	pygame.display.update()
	#Binarizacion
	im = Image.open("convolucion.jpg")
	pix = im.load()
	for x in range(0,ancho-1): #Ancho
	for y in range(0,largo-1): #Largo
	(r,g,b) = pix[x,y]
	promedio=(r+g+b)/3
	if promedio<=127:
	pix[x,y] =(0,0,0)
	else:
	pix[x,y] =(255,255,255)
	im.save('binarizada.jpg')
	imagen=pygame.image.load("binarizada.jpg")
	ventana.blit(imagen,(0,0))
	pygame.display.update()
	#BFS
	im = Image.open("binarizada.jpg")
	pix = im.load()
	for x in range(0,ancho-1): #Ancho
	for y in range(0,largo-1): #Largo
	if pix[x,y]==(0,0,0):
	rd=random.randint(0,255)
	gd=random.randint(0,255)
	bd=random.randint(0,255)
	r,g,b=(rd,gd,bd)
	arr=[]
	arr.append(actual)
	inicio=pix[actual]
	while len(arr)>0:
	(x,y)=arr.pop(0)
	actual=pix[x,y]
	if actual==inicio or actual ==color:
	if (pix[x-1,y]):
	if (pix[x-1,y]==inicio):
	pix[x-1,y]=color
	arr.append((x-1,y))
	except:
	pass
	try:
	if (pix[x+1,y]):
	if (pix[x+1,y]==inicio):
	pix[x+1,y]=color
	arr.append((x+1,y))
	except:
	pass
	try:
	if (pix[x,y-1]):
	if (pix[x,y-1]==inicio):
	pix[x,y-1]=color
	arr.append((x,y-1))
	except:
	pass
	try:
	if (pix[x,y+1]):
	if (pix[x,y+1]==inicio):
	pix[x,y+1]=color
	arr.append((x,y+1))
	except:
	pass
	im.save('deteccion.jpg')
	imagen=pygame.image.load("deteccion.jpg")
	ventana.blit(imagen,(0,0))
	pygame.display.update()
	actual=0,0
	while True:
	for event in pygame.event.get():
	if event.type == QUIT:
	exit()

view raw bfs.py hosted with ❤ by GitHub

Resultado:

Repositorio.
https://github.com/Sergiohdz/VisionComputacional

Laboratorio 2

Para esta entrega se nos pidió generar Ruido sal y pimienta en una imagen y después eliminarla.

Al generar el ruido sal y pimienta, hay que tener en cuenta la intensidad (que tanto se pone en la imagen) y la polarización (que tan negros y blancos son los puntos).

Y eliminar ruido sal y pimienta, esto con alguna combinación de filtrado/umbrales.

La imagen que utilice fue la siguiente:

Generar ruido sal y pimienta.

Esto lo realice con 2 variables random que serán las 2 coordenadas de la imagen (píxel) x,y. Y otra variable para generar un número aleatorio entre 0 y 255 para tener diferentes tonos de blancos/negros (polarización).

Código:

	#Ruido sal y pimienta
	polarizacion = 30 # Que tan Negros/Blancos seran los puntos / Entre mayor sea el numero seran mas negros
	intensidad = 10 # % de pixeles
	total=((900*603)/100)*intensidad
	im = Image.open("carro.jpg")
	pix = im.load()
	for i in range(0,total):
	x = random.randint(0, 900-1)
	y = random.randint(0, 603-1)
	syp=random.randint(0, 255-polarizacion)
	pix[x,y] =(syp,syp,syp)
	im.save('salypimienta.jpg')
	imagen=pygame.image.load("salypimienta.jpg")
	ventana.blit(imagen,(0,0))
	pygame.display.update()

view raw ruido.py hosted with ❤ by GitHub

Támbien se puede modificar la intensidad y polarización del ruido sal y pimienta, aquí muestro otros ejemplos de la imagen.

Intensidad 15% Polarización 0-245

Intensidad 30% Polarización 80-255

Intensidad 60% Polarización 155-255

Una vez generado el ruido, se realiza la eliminación/disminución de esté.

Esto lo realice sacando un promedio de los vecinos del píxel que se le haya aplicado ruido sal y pimienta.

	#Eliminacion de ruido sal y pimienta
	im = Image.open("salypimienta.jpg")
	pix = im.load()
	for x in range(2,900-2): #Ancho
	for y in range(2,603-2): #Largo
	r=0
	(r,g,b) = pix[x,y]
	if (pix[x,y]==(syp,syp,syp)):
	r+=pix[x+1,y][0]
	r+=pix[x-1,y][0]
	r+=pix[x,y+1][0]
	r+=pix[x,y-1][0]
	var=r/4
	pix[x,y]=(var,var,var)
	im.save('eliminacion.jpg')
	imagen=pygame.image.load("eliminacion.jpg")
	ventana.blit(imagen,(0,0))
	pygame.display.update()

view raw eliminacion.py hosted with ❤ by GitHub

Después se realiza un filtro para disminuir un poco más el ruido sal y pimienta en la imagen.

Aquí otro ejemplo de la generación/eliminación del ruido sal y pimienta.

Repositorio:  https://github.com/Sergiohdz/VisionComputacional

Tarea 1

Para esta tarea se nos pidió realizar una subrutina para aplicar una máscara de convolución discreta.

Con esa subrutina, calcular por lo menos un gradiente horizontal y un gradiente vertical.

Normalizar la matriz resultante de la manera que perciben factible y útil a [0, 255].

Y realizar la binarización que deje los bordes como zonas blancas y el resto negro.

Utilice el operador Sobel que calcula el gradiente de la intensidad de una imagen en cada píxel.

Lo primero que realice fue convertir la imagen a escala de grises (promediando los colores en rgb y asignándoles el promedio como nuevo valor al pixel).

Código en donde se realiza la escala de grises: 

	for x in range(0,1024): #Ancho
	for y in range(0,768): #Largo
	(r,g,b) = pix[x,y]
	promedio=(r+g+b)/3
	pix[x,y] =(promedio,promedio,promedio)

view raw escala.py hosted with ❤ by GitHub

Después de que se pasa la imagen a escala de grises se aplicará la máscara, en este caso utilice el operador Sobel.

Código en donde se aplica la máscara:

	dirX = ([-1, 0, 1], [-2, 0, 2], [-1, 0, 1])
	dirY = ([1, 2, 1], [0, 0, 0], [-1, -2, -1])
	for x in range(0,1024-3): #Ancho
	for y in range(0,768-3): #Largo
	sumDirX=0
	sumDirY=0
	for i in range(0,3):
	for j in range(0,3):
	sumDirX +=(pix[x+i,y+j][0]*dirX[i][j])
	sumDirY +=(pix[x+i,y+j][0]*dirY[i][j])
	potX = pow(sumDirX, 2)
	potY = pow(sumDirY, 2)
	res = int(math.sqrt(potX+potY))
	if res > 255:
	res = 255
	if res < 0:
	res = 0
	pix[x,y] = (res, res, res)

view raw mascara.py hosted with ❤ by GitHub

Una vez aplicada la máscara se realiza la binarización de la imagen.

En donde si el promedio del color en RGB del píxel es <= 127 se cambia el valor a (0,0,0) y en caso contrario se cambia a (255,255,255).

Código en donde se realiza la binarización: 

	for x in range(0,1024-1): #Ancho
	for y in range(0,768-1): #Largo
	(r,g,b) = pix[x,y]
	promedio=(r+g+b)/3
	if promedio<=127:
	pix[x,y] =(0,0,0)
	else:
	pix[x,y] =(255,255,255)

view raw binarizacion.py hosted with ❤ by GitHub

Tiempo de ejecución: 13.21 seg

Aquí les muestro otro ejemplo:

Imagen Normal:

Imagen Blanco y Negro:

Imagen con Máscara:

Imagen Binarizada:

Tiempo de ejecución: 10.43 seg

Repositorio: https://github.com/Sergiohdz/VisionComputacional

Laboratorio 1

Repositorio: https://github.com/Sergiohdz/VisionComputacional 

En el laboratorio 1 se pidió procesar una imagen y convertirla a escala de grises.

Para eso primero recorro cada pixel de la imagen y promedio la suma de los colores de cada pixel y asigno ese valor.

Por ejemplo si el color de un pixel es (100,120,80) asignaría a ese pixel el valor de (200,200,200).

Aquí les muestro el código:

	#!/usr/bin/python
	import pygame
	from pygame.locals import *
	import Image
	pygame.init()
	ventana=pygame.display.set_mode((1024,768))
	imagen=pygame.image.load("imagen.jpg")
	ventana.blit(imagen,(0,0))
	pygame.display.update()
	im = Image.open("imagen.jpg")
	pix = im.load()
	for x in range(0,1024): #Ancho
	for y in range(0,768): #Largo
	(r,g,b) = pix[x,y]
	promedio=(r+g+b)/3
	pix[x,y] =(promedio,promedio,promedio)
	im.save('escala.jpg')
	esc=pygame.image.load("escala.jpg")
	ventana.blit(esc,(0,0))
	pygame.display.update()
	while True:
	for event in pygame.event.get():
	if event.type == QUIT:
	exit()

view raw Convertir.py hosted with ❤ by GitHub

Vehículo Inteligente (Aplicaciones Emergentes)

En esta entrada muestro una aplicación que está en desarrollo y pudiera ser implementada en un futuro.

El smarphone sustituye a la llave del coche mediante NFC.

La aplicación se basa en la tecnología NFC (Near-Field Communication) que permitira a los smartphones ser utilizados como llave en un coche, ya que la tarjeta SIM contiene un archivo de datos grabado, a prueba de falsificaciones- con la autorización de acceso al vehículo.

Los receptores pueden ser instalados en las puertas del coche, en el portón trasero y dentro del maletero, permitiendo a futuras generaciones de teléfonos móviles ser recargados sin cables y arrancar el motor. 

Esta llave es activada a través de una web donde los propietarios registran sus datos y los del vehículo, así como los del dispositivo.  Los Smartphone no sólo desbloquean y abren las puertas de los coches, sino que también ofrece la conexión a internet.

Con esta función se podrían emplear muchas funcionalidad más, como preseleccionar radios preferidas, posición ideal de conducción o tener almacenados y preestablecidos los números de teléfono más importantes. Los datos de la tarjeta de memoria se sincronizarán automáticamente con el coche para extraer toda la información concerniente a su conductor. Además, con la llave virtual podrás acceder a tu coche a distancia.

Esta tecnología ofrece también protección anti-robos. El teléfono suena como una alarma en el momento que el vehículo es movido sin autorización. También se puede guardar la posición donde se encuentra el automóvil, cuando se va –por ejemplo- de compras o a un restaurante. El GPS es capaz de guiarnos hacia el lugar donde se encuentra estacionado el coche, si es que cuesta encontrarlo.

Conclusión:

Creo que sería una aplicación muy interesante ya que ha habido problemas con el duplicado de llaves en ciertos modelos/marcas de carros y con esta nueva tecnología sería mucho más seguro. 

Bibliografía:

http://alt1040.com/2012/12/nfc-smartphone-llave-coche

Vehículo Inteligente (Aplicaciones Existentes)

En esta entrada se pretende presentar trabajos relacionados con nuestro proyecto.

Nuestro proyecto trata de un Vehículo Inteligente con el que puedas saber si tu vehículo esta encendido, saber su ubicación por GPS en caso de robo, saber si está abierta una puerta mediante sensores o saber si la alarma se activó, etc.

VIPER SmartStart

Es una aplicación que permite realizar diferentes cosas desde un móvil:

·         Se puede bloquear/desbloquear el auto por medio del celular.

·         Tiene otras funciones remotas como:

·         Saber si el Motor esta (Encendido/Apagado)

·         Arranque de auto a distancia

·         Saber el estado de la Cajuela, Cofre, Puertas (Abiertas/Cerradas - Bloqueadas/Desbloqueadas)

·         Alarma (Activada/Desactivada)

·         Seguimiento GPS

Además puedes hacer que se activen ciertas funciones mediante mensajes de texto, o recibir alertas por correo.

Car Link

Esta aplicación permite varias funciones como lo son el:

·         Encendido a Control Remoto

·         Abrir puertas sin la llave

·         Bloquear, desbloquear y arrancar desde el Smartphone

·         Permite hacerlo con múltiplos vehículos

Conclusión:

Nuestra idea de proyecto es algo parecido a estas 2 aplicaciones que existen, la primera aplicación viene más completa y creo que son unas de las funciones en las que nos basaremos en nuestro proyecto. Saber los diferentes estados de las diferentes partes del automóvil (Puertas, Ventanas, Cajuela, Alarma, etc.).

Bibliografía:

http://www.viper.com/SmartStart/

http://www.voxcarlink.com/