ESCUELA SUPERIOR POLITCNICA DEL LITORAL

FACULTAD DE INGENIERIA EN ELECTRICIDAD Y COMPUTACION

PRACTICA #

DETECCION DE COLOR

INTEGRANTES:

Jonathan Parrales Neira

Alfonso Asitimbay Llivichuzhca

OBJETIVOS:

Aprender a utilizar el puente entre Python(x,y) y V-REP.

Aprender a identificar el color detectado por el sensor de visin.

FUNDAMENTOS TEORICOS:

Sensor de color comun: Los sensores de color de di-soric son ideales para
la medicin de color en ambientes industriales y para el reconocimiento de
colores en casi todas las reas de produccin. Debido a la percepcin utilizada
como principio de operacin, que es similar a la precisin del ojo humano, este
sensor puede ser utilizado en procesos de control de calidad. Adems de poder
reconocer cambios de coloracin, tambin es posible examinar y
evaluar diferentes estructuras superficiales.

La integridad de la estabilidad a largo plazo garantiza un funcionamiento seguro

tambin sobre un largo perodo de tiempo sin necesidad de tener que efectuar
una recalibracin. Su uso en condiciones de luminosidad del medioambiente
variable tambin es posible gracias a la compensacin interna de luz ambiental.

Los distinto modelos de sensores de color de esta familia de productos se

diferencian en funcin a las distintas pticas utilizadas, la capacidad lumnica y el
nmero de canales de medicin disponibles, lo que permite una eleccin
ptimapara cada aplicacin. Todos los sensores de color de di-soric se pueden
parametrizar mediante teclas de programacin o bien mediante un software de
configuracin, comn a todos los modelos.

Python XY: Python (x, y) es un software cientfico y

creado para el desarrollo de ingeniera libre en cuanto
al clculo numrico, anlisis de datos y visualizacin de
datos basados en lenguaje de programacin Python,
interfaces grficas de usuario Qt y Spyder entorno de desarrollo interactivo
cientfica.
Spider Lib: Es una biblioteca de objetos en Matlab, est diseado
para manejar (razonablemente) grandes problemas de
aprendizaje de mquina no supervisados, supervisados o semi-
supervisados. Tiene como objetivo convertirse en una completa
caja de herramientas de investigacin / anlisis: incluye
entrenamiento, pruebas, seleccin de modelos, pruebas estadsticas. Enchufar
objetos juntos: p.ej. realizar validacin cruzada en el siguiente sistema: seleccin
codiciosa de la funcin hacia atrs en un algoritmo de base rpida,
entrenamiento en aquellas caractersticas con un SVM para cada salida en un
sistema multi-clase de uno contra el resto, eligiendo todos los hiperparmetros
Con un mtodo
de seleccin
de modelo.

V-rep: El simulador de robot V-REP, con el entorno de desarrollo integrado, se

basa en una arquitectura de control distribuido: cada objeto / modelo puede ser
controlado de forma individual a travs de una secuencia de comandos
incrustada, un plug-in, un nodo de ROS, un cliente de API remota, o una solucin
personalizada. Esto hace que V-REP muy verstil y es ideal para aplicaciones
multi-robots. Los controladores pueden ser escritos en C / C ++, Python, Java,
Lua, Matlab o de octava. V-REP se utiliza para el desarrollo rpido de algoritmos,
simulaciones de automatizacin de fbricas, prototipado rpido y la verificacin,
la robtica educacin, monitoreo remoto relacionadas, seguridad doble control,
etc.
Brazo robotico pincher

PhantomX Pincher Arm El brazo robot

PhantomX Pincher Arm tiene 5 grados de
libertad: 4 de rotacion y 1 prism atico (4R1P) y
es simple de simular con el TurtleBot ROS
robot platform. Algunas de sus caractersticas
destacadas son: actuadores Dinamixel AX-12A,
construccion robusta ABS, Arbotix
Robocontroller para procesamiento a bordo y
soporte de montaje para camaras y sensores.

DESCRIPCION DEL PROGRAMA:

Valores de Colores
#Import Libraries:
import vrep #V-rep library
import sys
import math
from PIL import Image
import array
#Pre-Allocation

PI=math.pi #pi=3.14..., constant

vrep.simxFinish(-1) # just in case, close all opened connections

clientID=vrep.simxStart('127.0.0.1',19997,False,True,5000,5)

if clientID!=-1: #check if client connection successful

print( 'Connected to remote API server')

else:
print ('Connection not successful')
sys.exit('Could not connect')

#R indica Rojo
#G indica Verde
#B inidca Azul

errorCode,sensor=vrep.simxGetObjectHandle(clientID,'Vision_Sensor',vrep.sim
x_opmode_oneshot_wait)
returnCode,resolution,imagen=vrep.simxGetVisionSensorImage(clientID,sensor
,0,vrep.simx_opmode_oneshot_wait)
image_byte_array = array.array('b',imagen)
imagen_f = Image.frombuffer("RGB", (1,1), image_byte_array, "raw", "RGB", 0,
1)
pixeles = imagen_f.load()
for R in range (0,255+1):
for G in range (0,255+1):
for B in range (0,255+1):
if pixeles[0,0] == (R,G,B):
print(R)
print(G)
print(B)

Librera Curso
import vrep #V-rep library
from PIL import Image
import array
#Funciones
def movimiento(clientID,Movimiento_Brazo):
#Mueve los Brazos Roboticos
vrep.simxSetIntegerSignal(clientID,'Start',1,vrep.simx_opmode_oneshot)

vrep.simxSetIntegerSignal(clientID,'Movimiento_Brazo',Movimiento_Brazo,vrep.
simx_opmode_oneshot)
return
#Espera a que los dos brazos hayan terminado su movimiento
def esperar(clientID):
Confirmacion = 0

vrep.simxSetIntegerSignal(clientID,'Confirmacion',0,vrep.simx_opmode_onesho
t)
while Confirmacion!=1:

returnCode,Movimiento_Brazo_Robotico_Terminado=vrep.simxGetIntegerSign
al(clientID,'Movimiento_Brazo_Robotico_Terminado',vrep.simx_opmode_onesh
ot_wait)
Confirmacion = Movimiento_Brazo_Robotico_Terminado

vrep.simxSetIntegerSignal(clientID,'Confirmacion',1,vrep.simx_opmode_onesho
t)

returnCode,Movimiento_Brazo_Robotico_Terminado=vrep.simxGetIntegerSign
al(clientID,'Movimiento_Brazo_Robotico_Terminado',vrep.simx_opmode_onesh
ot_wait)
while Movimiento_Brazo_Robotico_Terminado!=0 :

returnCode,Movimiento_Brazo_Robotico_Terminado=vrep.simxGetIntegerSign
al(clientID,'Movimiento_Brazo_Robotico_Terminado',vrep.simx_opmode_onesh
ot_wait)

vrep.simxSetIntegerSignal(clientID,'Confirmacion',0,vrep.simx_opmode_onesho
t)
return
#Detecta los colores
def detector_de_color(clientID,Arreglo_Colores):
#Significado de los Numeros en Color
#Para Color Negro retorna 0
#Para Color Blanco retorna 1
#Para Color Rojo retorna 2
#Para Color Verde retorna 3
#Para Color Azul retorna 4
#Para Color Desconocido retorna 5
#Posicion de Numero Observados de Cada Color
#Arreglo_Colores=[Cantidad Negro, Cantidad Blanco, Cantidad Rojo,
Cantidad Verde, Cantidad Azul, Cantidad Desconocidos]
#Guarda el ID del Sensor de Vision

errorCode,Vision_Sensor=vrep.simxGetObjectHandle(clientID,'Vision_Sensor',v
rep.simx_opmode_oneshot_wait)

returnCode,resolution,imagen=vrep.simxGetVisionSensorImage(clientID,Vision
_Sensor,0,vrep.simx_opmode_oneshot_wait)
image_byte_array = array.array('b',imagen)
imagen_f = Image.frombuffer("RGB", (1,1), image_byte_array, "raw", "RGB",
0, 1)
pixeles = imagen_f.load()
for x in range (0,255+1):
if pixeles[0,0] == (x,x,x):
if x == 109 or x == 110 or x == 111 or x == 112:
Color = 0
Arreglo_Colores[0]=Arreglo_Colores[0]+1
break
elif x == 253 or x == 254 or x == 255:
Color = 1
Arreglo_Colores[1]=Arreglo_Colores[1]+1
break
elif pixeles[0,0] == (x,109,109) or pixeles[0,0] == (x,110,110) or pixeles[0,0]
== (x,111,111) or pixeles[0,0] == (x,112,112):
Color = 2
Arreglo_Colores[2]=Arreglo_Colores[2]+1
break
elif pixeles[0,0] == (109,x,109) or pixeles[0,0] == (110,x,110) or pixeles[0,0]
== (111,x,111) or pixeles[0,0] == (112,x,112):
Color = 3
Arreglo_Colores[3]=Arreglo_Colores[3]+1
break
elif pixeles[0,0] == (109,109,x) or pixeles[0,0] == (110,110,x) or pixeles[0,0]
== (111,111,x) or pixeles[0,0] == (112,112,x):
Color = 4
Arreglo_Colores[4]=Arreglo_Colores[4]+1
break
else:
if x == 255:
Color = 5
 Arreglo_Colores[5]=Arreglo_Colores[5]+1
break
return Color

Deteccion de color

#Import Libraries:
import vrep #V-rep library
import sys
import math
import Libreria_Curso
#--------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------
#Creacion del Puente entre V-REP y Python
PI=math.pi #pi=3.14..., constant
vrep.simxFinish(-1) # just in case, close all opened connections
clientID=vrep.simxStart('127.0.0.1',19997,False,True,5000,5)

if clientID!=-1: #check if client connection successful

print( 'Connected to remote API server')

else:
print( 'Connection not successful')
sys.exit('Could not connect')
#--------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------
#Constantes y Variables del Programa
Start=1
Movimiento_Brazo=8
Arreglo_Movimientos=[]
Arreglo_Colores=[0,0,0,0,0,0]
#--------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------
#Inicio del Programa
Libreria_Curso.movimiento(clientID,Movimiento_Brazo)
Libreria_Curso.esperar(clientID)
if Start==1:
vrep.simxSetIntegerSignal(clientID,'Start',0,vrep.simx_opmode_oneshot)
while True:
del Arreglo_Movimientos[:]

returnCode,detectionState=vrep.simxGetIntegerSignal(clientID,'Proximity_Sens
or_Signal',vrep.simx_opmode_oneshot_wait)
if detectionState == 0:
Color=Libreria_Curso.detector_de_color(clientID,Arreglo_Colores)
Movimiento_Brazo=1
Arreglo_Movimientos.append(Movimiento_Brazo)
Libreria_Curso.movimiento(clientID,Movimiento_Brazo)
Libreria_Curso.esperar(clientID)
 #En esta seccion del Codigo, procedemos a seleccionar el movimiento
correspondiente al color del bloque detectado por el sensor de vision
#Tambien se le da el valor a la variable Color en forma de String
if Color == 0:
Movimiento_Brazo=2
Libreria_Curso.movimiento(clientID,Movimiento_Brazo)
Libreria_Curso.esperar(clientID)
Color = 'Negro'
elif Color == 1:
Movimiento_Brazo=3
Libreria_Curso.movimiento(clientID,Movimiento_Brazo)
Libreria_Curso.esperar(clientID)
Color = 'Blanco'
elif Color == 2:
Movimiento_Brazo=4
Libreria_Curso.movimiento(clientID,Movimiento_Brazo)
Libreria_Curso.esperar(clientID)
Color = 'Rojo'
elif Color == 3:
Movimiento_Brazo=5
Libreria_Curso.movimiento(clientID,Movimiento_Brazo)
Libreria_Curso.esperar(clientID)
Color = 'Verde'
elif Color == 4:
Movimiento_Brazo=6
Libreria_Curso.movimiento(clientID,Movimiento_Brazo)
Libreria_Curso.esperar(clientID)
Color = 'Azul'
else:
Movimiento_Brazo=7
Libreria_Curso.movimiento(clientID,Movimiento_Brazo)
Libreria_Curso.esperar(clientID)
Color = 'Desconocido'
Arreglo_Movimientos.append(Movimiento_Brazo)
print('------------------------------')
print('Color: ' + Color)
print('Movimiento 1: ' + str(Arreglo_Movimientos[0]) + ' Movimiento 2: ' +
str(Arreglo_Movimientos[1]))
print('Cantidad Cubos Negros: ' + str(Arreglo_Colores[0]))
print('Cantidad Cubos Blancos: ' + str(Arreglo_Colores[1]))
print('Cantidad Cubos Rojos: ' + str(Arreglo_Colores[2]))
print('Cantidad Cubos Verdes: ' + str(Arreglo_Colores[3]))
print('Cantidad Cubos Azules: ' + str(Arreglo_Colores[4]))
print('Cantidad Cubos Desconocidos: ' + str(Arreglo_Colores[5]))
else:
Movimiento_Brazo=8
Libreria_Curso.movimiento(clientID,Movimiento_Brazo)
Libreria_Curso.esperar(clientID)
else:
vrep.simxSetIntegerSignal(clientID,'Start',0,vrep.simx_opmode_oneshot)
Capturas de Pantalla

Azul
Rojo
Negro
Verde
Blanco

CONCLUSIONES:

Una vez desactivada la luz en el archivo del v-rep se de debe proceder a tomar
los nuevos valores del sensor de color para los casos prioritarios a la prctica
como el color: rojo, blanco, negro, azul y verde.

Luego se procede a actualizar esos valores en el cdigo del archivo

Librera_Curso.
Y finalmente con el archivo Tutorial Deteccin de Color se puede hacer la
simulacin del brazo robot en el cual va seleccionando las cajas por su color y
agrupando en la banda transportadora segn su respectivo color.

BIBLIOGRAFIA:

https://python-xy.github.io/

http://people.kyb.tuebingen.mpg.de/spider/

http://www.coppeliarobotics.com/