def encontra_circulo(img, codigo_cor):
# MAGENTA
hsv_1, hsv_2 = aux.ranges(codigo_cor)
# convert the image to grayscale, blur it, and detect edges
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
color_mask = cv2.inRange(hsv, hsv_1, hsv_2)
segmentado = cv2.morphologyEx(color_mask, cv2.MORPH_CLOSE, np.ones(
(10, 10)))
segmentado = cv2.adaptiveThreshold(segmentado,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,\
cv2.THRESH_BINARY,11,3.5)
kernel = np.ones((3, 3), np.uint8)
segmentado = cv2.erode(segmentado, kernel, iterations=1)
circles = cv2.HoughCircles(segmentado,
cv2.HOUGH_GRADIENT,
2,
40,
param1=50,
param2=100,
minRadius=5,
maxRadius=100)
return circles
def encontra_marcador(img):
# convert the image to grayscale, blur it, and detect edges
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Cria máscara para a cor magenta
hsv1, hsv2 = aux.ranges('#FF00FF')
mask = cv2.inRange(hsv, hsv1, hsv2)
blur = cv2.GaussianBlur(mask, (5, 5), 0)
edged = cv2.Canny(blur, 35, 125)
# find the contours in the edged image and keep the largest one;
cnts = cv2.findContours(edged.copy(), cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
c = max(cnts, key=cv2.contourArea)
# compute the bounding box of the of the paper region and return it
return cv2.minAreaRect(c)
ret, frame = video1.read()
if ret == False:
print("Codigo de retorno FALSO - problema para capturar o frame")
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
if n == "3":
frame=cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
white = "#eb4034"
white_1, white_2 = aux.ranges(white)
branco_1 = np.array([0, 0, 210], dtype=np.uint8)
branco_2 = np.array([255, 40, 255], dtype=np.uint8)
mask_white = cv2.inRange(hsv, branco_1, branco_2)
edges = cv2.Canny(gray,50,150,apertureSize = 3)
lines = cv2.HoughLines(mask_white,1,np.pi/180, 200)
for i in range(0, len(lines)):
r = lines[i][0][0]
theta = lines[i][0][1]
a = np.cos(theta)
b = np.sin(theta)
x0 = a*r
def identifica_cor(frame):
'''
Segmenta o maior objeto cuja cor é parecida com cor_h (HUE da cor, no espaço HSV).
'''
# No OpenCV, o canal H vai de 0 até 179, logo cores similares ao
# vermelho puro (H=0) estão entre H=-8 e H=8.
# Precisamos dividir o inRange em duas partes para fazer a detecção
# do vermelho:
# frame = cv2.flip(frame, -1) # flip 0: eixo x, 1: eixo y, -1: 2 eixos
frame_hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
"""Não sabemos se isso é RGB ou não"""
# cor_menor = np.array([37, 50, 50])
# cor_maior = np.array([47, 255, 255])
"""
Utilizando uma função passada pelo professor na Atividade 2,
podemos entregar ao programa uma lista com valores [R,G,B] e
a função "ranges" do módulo auxiliar converte em HSV (formato)
lido pelo openCV e devolve os dois valores que precisamos:
cor_menor, cor_maior
"""
cor_menor, cor_maior = aux.ranges(
[0, 99, 7]) # devolve dois valores: hsv_menor e hsv_maior
segmentado_cor = cv2.inRange(frame_hsv, cor_menor, cor_maior)
#cor_menor = np.array([172, 50, 50])
#cor_maior = np.array([180, 255, 255])
#segmentado_cor += cv2.inRange(frame_hsv, cor_menor, cor_maior)
# Note que a notacão do numpy encara as imagens como matriz, portanto o enderecamento é
# linha, coluna ou (y,x)
# Por isso na hora de montar a tupla com o centro precisamos inverter, porque
centro = (frame.shape[1] // 2, frame.shape[0] // 2)
def cross(img_rgb, point, color, width, length):
cv2.line(img_rgb, (point[0] - length / 2, point[1]),
(point[0] + length / 2, point[1]), color, width, length)
cv2.line(img_rgb, (point[0], point[1] - length / 2),
(point[0], point[1] + length / 2), color, width, length)
# A operação MORPH_CLOSE fecha todos os buracos na máscara menores
# que um quadrado 7x7. É muito útil para juntar vários
# pequenos contornos muito próximos em um só.
segmentado_cor = cv2.morphologyEx(segmentado_cor, cv2.MORPH_CLOSE,
np.ones((7, 7)))
# Encontramos os contornos na máscara e selecionamos o de maior área
#contornos, arvore = cv2.findContours(segmentado_cor.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
contornos, arvore = cv2.findContours(segmentado_cor.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
maior_contorno = None
maior_contorno_area = 0
for cnt in contornos:
area = cv2.contourArea(cnt)
if area > maior_contorno_area:
maior_contorno = cnt
maior_contorno_area = area
# Encontramos o centro do contorno fazendo a média de todos seus pontos.
if not maior_contorno is None:
cv2.drawContours(frame, [maior_contorno], -1, [0, 0, 255], 5)
maior_contorno = np.reshape(maior_contorno,
(maior_contorno.shape[0], 2))
media = maior_contorno.mean(axis=0)
media = media.astype(np.int32)
cv2.circle(frame, (media[0], media[1]), 5, [0, 255, 0])
cross(frame, centro, [255, 0, 0], 1, 17)
else:
media = (0, 0)
# Representa a area e o centro do maior contorno no frame
font = cv2.FONT_HERSHEY_COMPLEX_SMALL
cv2.putText(frame, "{:d} {:d}".format(*media), (20, 100), 1, 4,
(255, 255, 255), 2, cv2.LINE_AA)
cv2.putText(frame, "{:0.1f}".format(maior_contorno_area), (20, 50), 1, 4,
(255, 255, 255), 2, cv2.LINE_AA)
# cv2.imshow('video', frame)
cv2.imshow('seg', segmentado_cor)
cv2.waitKey(1)
return media, centro, maior_contorno_area
while (True):
# Capture frame-by-frame
ret, frame = cap.read()
if ret == False:
print("Codigo de retorno FALSO - problema para capturar o frame")
# Our operations on the frame come here
rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
#1. Transformar em HSV
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
#2. aux
cap_pink1, cap_pink2 = aux.ranges(pink)
mask_pink = cv2.inRange(hsv, cap_pink1, cap_pink2)
# Blue
cap_blue1, cap_blue2 = aux.ranges(blue)
mask_blue = cv2.inRange(hsv, cap_blue1, cap_blue2)
mask = mask_blue + mask_pink
cv2.imshow("mask", mask)
# Display the resulting frame
# cv2.imshow('frame',frame)
cv2.imshow('gray', gray)
if cv2.waitKey(1) & 0xFF == ord('q'):
h = 560
f = (h*D)/H
while(True):
# Capture frame-by-frame
ret, frame = cap.read()
# Convert the frame to grayscale and hsv
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
magenta='#FF00FE'
hsv1_m, hsv2_m = aux.ranges(magenta)
mask_m = cv2.inRange(hsv, hsv1_m, hsv2_m)
ciano='#00FFFF'
hsv1_c, hsv2_c = aux.ranges(ciano)
mask_c = cv2.inRange(hsv, hsv1_c, hsv2_c)
blur_mag = cv2.GaussianBlur(mask_m,(5,5),0)
blur_cya = cv2.GaussianBlur(mask_c,(5,5),0)
blur = cv2.add(blur_cya, blur_mag)
# Detect the edges present in the image
bordas_m = auto_canny(blur_mag)
bordas_c = auto_canny(blur_cya)
# return the edged image
return edged
while(True):
# Capture frame-by-frame
ret, frame = cap.read()
if ret == False:
print("Codigo de retorno FALSO - problema para capturar o frame")
# Our operations on the frame come here
bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
cor_ciano = "#056bab"
cor1_ciano, cor2_ciano = aux.ranges(cor_ciano)
img_rgb_ciano = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
img_hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mascara_ciano = cv2.inRange(img_hsv, cor1_ciano, cor2_ciano)
cor_magenta= "#90183c"
cor1_magenta, cor2_magenta = aux.ranges(cor_magenta)
img_rgb_magenta = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
img_hsv_magenta = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mascara_magenta = cv2.inRange(img_hsv_magenta, cor1_magenta, cor2_magenta)
mascara = mascara_ciano+mascara_magenta
# Display the resulting frame
# cv2.imshow('frame',frame)
import time as t
import sys
import math
import auxiliar as aux
import imutils
cap = cv2.VideoCapture(0)
img_color = cv2.imread("folha_atividade.png")
img_rgb = cv2.cvtColor(img_color, cv2.COLOR_BGR2RGB)
img_hsv = cv2.cvtColor(img_color, cv2.COLOR_BGR2HSV)
magenta = "#EA148D"
cyan = "#01AFEC"
cor1, cor2 = aux.ranges(cyan)
mag1 = np.array([170, 50, 50], dtype=np.uint8)
mag2 = np.array([200, 255, 255], dtype=np.uint8)
cy1 = np.array([100, 50, 50], dtype=np.uint8)
cy2 = np.array([110, 255, 255], dtype=np.uint8)
print(cor1, cor2)
def auto_canny(image, sigma=0.33):
# compute the median of the single channel pixel intensities
v = np.median(image)
# apply automatic Canny edge detection using the computed median
lower = int(max(0, (1.0 - sigma) * v))
upper = int(min(255, (1.0 + sigma) * v))
def auto_canny(image, sigma=0.33):
# compute the median of the single channel pixel intensities
v = np.median(image)
# apply automatic Canny edge detection using the computed median
lower = int(max(0, (1.0 - sigma) * v))
upper = int(min(255, (1.0 + sigma) * v))
edged = cv2.Canny(image, lower, upper)
# return the edged image
return edged
while (True):
# MAGENTA
hsv_m1, hsv_m2 = aux.ranges('#FF00FF')
# CIANO
hsv_c1, hsv_c2 = aux.ranges('#5dbcce')
# Capture frame-by-frame
ret, frame = cap.read()
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
#Craindo e aplicando as máscaras
mask_m = cv2.inRange(hsv, hsv_m1, hsv_m2)
mask_c = cv2.inRange(hsv, hsv_c1, hsv_c2)
mask = mask_c + mask_m
segmentado = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, np.ones((10, 10)))
# HoughCircles - detects circles using the Hough Method. For an explanation of
# param1 and param2 please see an explanation here http://www.pyimagesearch.com/2014/07/21/detecting-circles-images-using-opencv-hough-circles/
circles = None
circles = cv2.HoughCircles(bordas,
cv2.HOUGH_GRADIENT,
2,
40,
param1=50,
param2=80,
minRadius=5,
maxRadius=40)
# Our operations on the frame come here
rgb = frame #cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
#gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
rosa1, rosa2 = aux.ranges(rosa)
azul1, azul2 = aux.ranges(azul)
maskrosa = cv2.inRange(hsv, rosa1, rosa2)
maskazul = cv2.inRange(hsv, azul1, azul2)
masktotal = maskazul + maskrosa
if circles is not None:
circles = np.uint16(np.around(circles))
for i in circles[0, :]:
coef = 0
# draw the outer circle
cv2.circle(masktotal, (i[0], i[1]), i[2], (0, 255, 0), 2)
# draw the center of the circle
cv2.circle(masktotal, (i[0], i[1]), 2, (0, 0, 255), 3)
print("TOTAL:", i)
# cv2.circle(img, center, radius, color[, thickness[, lineType[, shift]]])
lower = 0
upper = 1
print("Press q to QUIT")
while(True):
# Capture frame-by-frame
ret, frame = cap.read()
# Convert the frame to rgb
img_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
img_hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
if cor == 'm':
hsv1, hsv2 = aux.ranges('#FF00FF')
elif cor == 'c':
hsv1, hsv2 = aux.ranges('#00FFFF')
mask = cv2.inRange(img_hsv, hsv1, hsv2)
selecao = cv2.bitwise_and(img_rgb, img_rgb, mask=mask)
segmentado_cor = cv2.morphologyEx(mask,cv2.MORPH_CLOSE,np.ones((10, 10)))
selecao = cv2.bitwise_and(img_rgb, img_rgb, mask=segmentado_cor)
contornos, arvore = cv2.findContours(segmentado_cor.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img_rgb, contornos, -1, [0, 0, 255], 3);
# cv2.putText(img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]])
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(img_rgb,'Press q to quit',(0,50), font, 1,(255,255,255),2,cv2.LINE_AA)
def identifica_cor(frame):
'''
Segmenta o maior objeto cuja cor é parecida com cor_h (HUE da cor, no espaço HSV).
'''
colorpicker = widgets.ColorPicker(concise=False,
description='Escolha uma cor',
value='#01ff13',
disabled=False)
hsv1, hsv2 = aux.ranges(colorpicker.value)
# No OpenCV, o canal H vai de 0 até 179, logo cores similares ao
# vermelho puro (H=0) estão entre H=-8 e H=8.
# Precisamos dividir o inRange em duas partes para fazer a detecção
# do vermelho:
# frame = cv2.flip(frame, -1) # flip 0: eixo x, 1: eixo y, -1: 2 eixos
frame_hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
#cor_menor = np.array([52, 50, 50])
#cor_maior = np.array([62, 255, 255])
segmentado_cor = cv2.inRange(frame_hsv, hsv1, hsv2)
#cor_menor = np.array([172, 50, 50])
#cor_maior = np.array([180, 255, 255])
#segmentado_cor += cv2.inRange(frame_hsv, cor_menor, cor_maior)
# Note que a notacão do numpy encara as imagens como matriz, portanto o enderecamento é
# linha, coluna ou (y,x)
# Por isso na hora de montar a tupla com o centro precisamos inverter, porque
centro = (frame.shape[1] // 2, frame.shape[0] // 2)
def cross(img_rgb, point, color, width, length):
cv2.line(img_rgb, (point[0] - length / 2, point[1]),
(point[0] + length / 2, point[1]), color, width, length)
cv2.line(img_rgb, (point[0], point[1] - length / 2),
(point[0], point[1] + length / 2), color, width, length)
# A operação MORPH_CLOSE fecha todos os buracos na máscara menores
# que um quadrado 7x7. É muito útil para juntar vários
# pequenos contornos muito próximos em um só.
segmentado_cor = cv2.morphologyEx(segmentado_cor, cv2.MORPH_CLOSE,
np.ones((7, 7)))
# Encontramos os contornos na máscara e selecionamos o de maior área
#contornos, arvore = cv2.findContours(segmentado_cor.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
contornos, arvore = cv2.findContours(segmentado_cor.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
maior_contorno = None
maior_contorno_area = 0
for cnt in contornos:
area = cv2.contourArea(cnt)
if area > maior_contorno_area:
maior_contorno = cnt
maior_contorno_area = area
# Encontramos o centro do contorno fazendo a média de todos seus pontos.
if not maior_contorno is None:
cv2.drawContours(frame, [maior_contorno], -1, [0, 0, 255], 5)
maior_contorno = np.reshape(maior_contorno,
(maior_contorno.shape[0], 2))
media = maior_contorno.mean(axis=0)
media = media.astype(np.int32)
cv2.circle(frame, (media[0], media[1]), 5, [255, 0, 0])
cross(frame, centro, [0, 255, 0], 1, 17)
else:
media = (0, 0)
# Representa a area e o centro do maior contorno no frame
font = cv2.FONT_HERSHEY_COMPLEX_SMALL
cv2.putText(frame, "{:d} {:d}".format(*media), (20, 100), 1, 4,
(255, 255, 255), 2, cv2.LINE_AA)
cv2.putText(frame, "{:0.1f}".format(maior_contorno_area), (20, 50), 1, 4,
(255, 255, 255), 2, cv2.LINE_AA)
# cv2.imshow('video', frame)
cv2.imshow('seg', segmentado_cor)
cv2.waitKey(1)
return media, centro, maior_contorno_area