def roda_todo_frame(imagem):
global cv_image
global media
global centro
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime # calcula o lag
delay = lag.nsecs
if delay > atraso and check_delay == True:
print("Descartando por causa do delay do frame:", delay)
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
centro, imagem, resultados = visao_module.processa(cv_image)
media, centro, area = cormodule.identifica_cor(cv_image)
for i in resultados:
if i[0] == "car":
global isCar
isCar = True
depois = time.clock()
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
print("frame")
global cv_image
global media
global centro
global area
#global distancia
global now
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime
delay = lag.nsecs
if delay > atraso and check_delay == True:
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
media, centro, area = cormodule.identifica_cor(
cv_image) #distancia removida#
#laser = le_scan.scaneou(dado)
depois = time.clock()
Features(cv_image)
#HoughLinesCode(cv_image)
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
global cv_image
global media
global centro_pista
global resultados
global centro_robo
global media_creep
global maior_area
try:
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
img_copy = cv_image.copy()
img_copy_pista = cv_image.copy()
img_copy_aruco = cv_image.copy()
img_copy_cor = cv_image.copy()
centro_pista, antolho, mask = procImg.procesa_imagem_pista(img_copy_pista)
# cv2.imshow("antolho", antolho)
cv2.imshow("mask", mask)
media_creep, maior_area, frame = cormodule.identifica_cor(img_copy_cor, goal1[0])
centro_robo = (img_copy.shape[1]//2, img_copy.shape[0]//2)
if centro_pista is not None:
crosshair(frame, centro_pista, 4, (0,0,255))
# cv2.imshow("cv_image", cv_image)
cv2.imshow("cor", frame)
cv2.waitKey(1)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
print("frame")
global cv_image
global media
global centro
global contornos
global dx
global stop
global bird
global contador
global centro_bird
global red
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime # calcula o lag
delay = lag.nsecs
print("delay ", "{:.3f}".format(delay / 1.0E9))
if delay > atraso and check_delay == True:
print("Descartando por causa do delay do frame: ", delay)
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
dx = cv_image.shape[1] // 10
depois = time.clock()
media, centro, area = cormodule.identifica_cor(cv_image)
if media[0] + media[1] != 0:
red = True
else:
red = False
centro, imagem, resultados = visao_module.processa(cv_image)
cv2.line(cv_image, (centro[0] + dx, 0),
(centro[0] + dx, cv_image.shape[1]), (0, 0, 255), 2)
cv2.line(cv_image, (centro[0] - dx, 0),
(centro[0] - dx, cv_image.shape[1]), (0, 0, 255), 2)
if resultados[0][0] == "bird":
print("PASSAROOOOOOOOOOOOOOO")
bird = True
x0, y0 = resultados[0][2]
x1, y1 = resultados[0][3]
centro_bird = [x0 + (x1 - x0) // 2, y0 + (y1 - y0) // 2]
cv2.circle(cv_image, (centro_bird[0], centro_bird[1]), 5,
(0, 0, 255), -1)
else:
bird = False
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
global cv_image
global media
global centro_cor
global centro_mobile
global viu_bird
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime # calcula o lag
delay = lag.nsecs
if delay > atraso and check_delay == True:
print("Descartando por causa do delay do frame:", delay)
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
media, centro_cor, area = cormodule.identifica_cor(cv_image)
centro_mobile, imagem, resultados = visao_module.processa(cv_image)
depois = time.clock()
for r in resultados:
if r[0] == "bird":
viu_bird = True
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
# print("frame")
global cv_image
global media
global centro
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now-imgtime # calcula o lag
delay = lag.nsecs
#print("delay ", "{:.3f}".format(delay/1.0E9))
if delay > atraso and check_delay==True:
print("Descartando por causa do delay do frame:", delay)
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
media, centro, area = cormodule.identifica_cor(cv_image)
depois = time.clock()
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
#print("frame")
global cv_image
global media
global centro
global media1
global maior_area
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime # calcula o lag
delay = lag.nsecs
#print("delay ", "{:.3f}".format(delay/1.0E9))
if delay > atraso and check_delay == True:
#print("Descartando por causa do delay do frame:", delay)
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
cv_image2 = cv_image.copy()
# cv_image = cv2.flip(cv_image, -1) # Descomente se for robo real
media, centro = cormodule.identifica_cor(
cv_image
) #puxa arquivo cormodule.py (centro = centro da image) (media= centro do maior contronro da cor desejada) (maior_area= tamanaho da area d maior contorno)
media1, maior_area = identifica_creeper(cv_image2)
depois = time.clock()
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
print("frame")
global cv_image
global media_cor
global centro
global area
global menorDist
global aceleracao
global media_feature
global centro_feature
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime
delay = lag.nsecs
if delay > atraso and check_delay == True:
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
media_cor, centro, area = cormodule.identifica_cor(cv_image)
media_feature, centro_feature = identifica_feature(cv_image)
#scaneou(cv_image)
depois = time.clock()
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def identifica_cor(imagem):
global areaCor
global cv_image
global mediaCor
global centroCor
global viu_cor
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime
delay = lag.nsecs
if delay > atraso and check_delay == True:
print("Descartando por causa do delay do frame:", delay)
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
mediaCor, centroCor, areaCor = cormodule.identifica_cor(
cv_image, margin)
print(mediaCor)
viu_cor = True
depois = time.clock()
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
print("frame")
global cv_image
global ccaixa
global cimagem
global classe
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime # calcula o lag
delay = lag.nsecs
print("delay ", "{:.3f}".format(delay / 1.0E9))
if delay > atraso and check_delay == True:
print("Descartando por causa do delay do frame:", delay)
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
cv_image = cv2.flip(cv_image, -1)
centro, imagem, classe = visao_module.processa(cv_image)
documenta_visual(classe)
ccaixa, cimagem, area = cormodule.identifica_cor(cv_image)
depois = time.clock()
cv2.line(cv_image, (cimagem[0] - tolerancia, 0),
(cimagem[0] - tolerancia, cv_image.shape[0] - 1), (255, 0, 0),
5)
cv2.line(cv_image, (cimagem[0] + tolerancia, 0),
(cimagem[0] + tolerancia, cv_image.shape[0] - 1), (255, 0, 0),
5)
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
global objeto, kp1, des1
global bbox, contador, frame
global media_cor, centro, area, fuga
# print("New Frame")
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime
delay = lag.nsecs
if delay > atraso and check_delay == True:
return #Ou seja, para a função e descarta o frame
try:
frame = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
frame_cor = frame.copy()
media_cor, area = cormodule.identifica_cor(frame_cor)
# print(area)
if area > 14000:
fuga = True
else:
fuga = False
vai(frame, contador)
contador += 1
if contador > 2:
contador = 0
except CvBridgeError as e:
print('ex', e)
def cam_data(imagem):
global centro
global bridge
global cv_image
global dif
global media_blue
global see_bottle
global tracking_bottle
global consecutive_frame
global xy1
global xy0
global fps
global initBB
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime # calcula o lag
delay = lag.nsecs
if delay > atraso and check_delay == True:
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
centro_red, centro, media_blue, area_blue = cormodule.identifica_cor(
cv_image, margem, margem_vertical)
if not tracking_bottle:
centro, cv_image, results = visao_module.processa(cv_image)
for e in results:
if e[0] == "bottle":
xy0 = e[2]
xy1 = e[3]
x0, y0 = xy0
x1, y1 = xy1
centro_bottle = (x1 - x0, y1 - y0)
# dif = centro_bottle[0]-centro[1]
saw_bottle = True
consecutive_frame += 1
if consecutive_frame == 10:
tracking_bottle = True
initBB = (x0, y0, x1, y1)
if tracking_bottle:
tracker.init(cv_image, initBB)
fps = FPS().start()
(success, box) = tracker.update(cv_image)
if success:
(x, y, w, h) = [int(v) for v in box]
cv2.rectangle(cv_image, (x, y), (x + w, y + h), (0, 255, 0), 2)
centro_bottle = (x + w / 2, y + h / 2)
dif = centro_bottle[0] - centro[1]
fps.update()
fps.stop()
cv2.imshow("frame", cv_image)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(img):
global cv_image
global media
global centro
try:
cv_image = bridge.compressed_imgmsg_to_cv2(img, "bgr8")
media, centro, maior_area = identifica_cor(cv_image)
except CvBridgeError as e:
print("ex", e)
def acha_cor(imagem):
global cv_image
global media
global centro
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
media, centro, area = cormodule.identifica_cor(
cv_image) #media -> centro do contorno #Centro -> centro da tela
global dx
dx = media[0] - centro[1] # centro (y,x) media (x,y)
global dy
dy = media[1] - centro[0]
def Segue_cor(imagem):
# now = rospy.get_rostime()
# imgtime = imagem.header.stamp
# lag = now-imgtime # calcula o lag
# delay = lag.nsecs
# print("delay ", "{:.3f}".format(delay/1.0E9))
# if delay > atraso and check_delay==True:
# print("Descartando por causa do delay do frame:", delay)
# return
antes = time.clock()
# cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
media_cor, centro, area = cormodule.identifica_cor(imagem)
depois = time.clock()
return media_cor
def roda_todo_frame(imagem):
print("frame")
global temp_image
global media
global centro
global resultados
global distance
global ids
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime # calcula o lag
delay = lag.nsecs
# print("delay ", "{:.3f}".format(delay/1.0E9))
if delay > atraso and check_delay == True:
# Esta logica do delay so' precisa ser usada com robo real e rede wifi
# serve para descartar imagens antigas
print("Descartando por causa do delay do frame:", delay)
return
try:
temp_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
mask = segmenta_linha_amarela(temp_image)
img = ajuste_linear_grafico_x_fy(mask)
"""Aqui é onde definimos nossas missões, sendo estas a cor e o id"""
#missao = ["orange", 11, "cow"]
missao = ["blue", 12, "dog"]
#missao = ["green", 23, "horse"]
#missao = ["Teste", 0, 0]
acha_creeper(missao, temp_image.copy())
media, centro, maior_area = cormodule.identifica_cor(mask)
cv2.imshow("Camera", img)
cv2.waitKey(1)
centro, saida_net, resultados = visao_module.processa(temp_image)
distance, ids = acha_aruco(temp_image)
ids = ids[0][0]
print("ids:", ids)
cv2.imshow("Aruco", temp_image)
cv2.waitKey(1)
for r in resultados:
# print(r) - print feito para documentar e entender
# o resultado
pass
# Desnecessário - Hough e MobileNet já abrem janelas
#cv_image = saida_net.copy()
#cv2.imshow("cv_image", img)
#cv2.waitKey(1)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
global cv_image
global media
global centro
global area
global resultados_mnet
global tracking
global contador
global V
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime # calcula o lag
delay = lag.nsecs
if delay > atraso and check_delay == True:
print("Descartando por causa do delay do frame:", delay)
return
try:
if mnet.contador_mnet == 0 and contador == 10:
contador = 0
mnet.contador_mnet = 1000
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
media, centro, area = cormodule.identifica_cor(cv_image)
if area <= 0:
V = 0
else:
V = 10000 / area
imagem_ = cv_image
if contador < 10 and contador >= 0:
centro_mnet, imagem_, resultados_mnet = visao_module.processa(
cv_image)
tracking = False
if len(resultados_mnet) != 0:
contador += 1
else:
contador = 0
elif contador >= 10:
tracking = True
mnet.track(cv_image)
depois = time.clock()
cv2.imshow("Camera", imagem_)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
global cv_image
global media
global centro
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime # calcula o lag
delay = lag.nsecs
if delay > atraso and check_delay == True:
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
# cv_image = cv2.flip(cv_image, -1)
media, centro, maior_area = cormodule.identifica_cor(cv_image)
depois = time.clock()
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
#print("frame")
global cv_image
global media
global centro
global maior_area
global colorLowRange
global colorHighRange
global frame_hsv
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now-imgtime # calcula o lag
delay = lag.nsecs
#print("delay ", "{:.3f}".format(delay/1.0E9))
if delay > atraso and check_delay==True:
print("Descartando por causa do delay do frame:", delay)
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
# cv_image = cv2.flip(cv_image, -1)
frame_hsv = cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV)
media, centro, maior_area = cormodule.identifica_cor(cv_image, colorLowRange, colorHighRange)
#verde (36,80, 80), (70,255,255)
depois = time.clock()
# cv2.imshow("Camera", cv_image)
# print("Média: ", media)
# print("Centro: ", centro)
# print("Maior Área: ", maior_area)
except CvBridgeError as e:
#print('ex', e)
print("")
def roda_todo_frame(imagem):
print("frame")
global cv_image
global resultados
global media
global centro
global temp_image
global ptom
global pto
global linha1
global linha2
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime # calcula o lag
delay = lag.nsecs
print("delay ", "{:.3f}".format(delay / 1.0E9))
if delay > atraso and check_delay == True:
print("Descartando por causa do delay do frame:", delay)
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
# media, centro, maior_area = cormodule.identifica_cor(
# cv_image, lista_quero[0])
centro, saida_net, resultados = visao_module.processa(temp_image)
media, centro, maior_contorno_area = cormodule.identifica_cor(
cv_image, lista_quero[0])
ptom = pto_fuga.acha_ponto(cv_image)
for r in resultados:
# print(r)
pass
depois = time.clock()
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
print("frame")
global cv_image
global media
global centro
global area
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime
delay = lag.secs
if delay > atraso and check_delay == True:
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
media, centro, area = cormodule.identifica_cor(cv_image)
print("media {},{}".format(*media))
print("centro {},{}".format(*centro))
depois = time.clock()
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
# print("frame")
global cv_image
global media
global centro
global viu_objeto
global pos_x
global area
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now-imgtime # calcula o lag
delay = lag.nsecs
#print("delay ", "{:.3f}".format(delay/1.0E9))
if delay > atraso and check_delay==True:
print("Descartando por causa do delay do frame:", delay)
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
media, centro, area = cormodule.identifica_cor(cv_image)
centro1, imagem1, resultados = visao_module.processa(cv_image)
for r in resultados:
# print(r) - print feito para documentar e entender
# o resultado
if r[0] == (objeto):
viu_objeto = True
pos_x = (r[2][0]+r[3][0])/2
depois = time.clock()
depois = time.clock()
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
global cv_image
global media
global centro
global area
global coringao
global caixa_cor
global f
f += 1
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime
delay = lag.nsecs
# tratando o delay
if delay > atraso and check_delay == True:
print("delay {:.2f}".format(delay / 1.0E9))
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
# identifica o símbolo do corinthians
media, centro, area, caixa_cor = cormodule.identifica_cor(cv_image)
# 1 frame a cada 3
if f % 3 == 0:
media_corin, coringao = corinthians.procuracor(cv_image)
media_corin = (0, 0)
if media_corin[0] != 0:
media = media_corin
depois = time.clock()
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def run_all_frames(imagem):
global cv_image
global media
global centro
global cap_lock
global frame_capturado
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now-imgtime # calcula o lag
delay = lag.nsecs
print("delay ", "{:.3f}".format(delay/1.0E9))
if delay > atraso and check_delay==True:
print("Descartando por causa do delay do frame:", delay)
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
#cv_image = cv2.flip(cv_image, -1)
media, centro, maior_area = cormodule.identifica_cor(cv_image)
if cap_lock == 0:
frame_capturado = cv_image
else:
cap_lock -= 1
depois = time.clock()
return
except CvBridgeError as e:
print('ex', e)
def CamView(imagem):
global cv_image
global media
global centro
global media_cor
global centro_cor
global area_cor
global viu_obj
global is_centered
global coef
global objeto
global x_obj
global dist_obj_centro_imagem_x
global contador_objeto
global detect_mode
global initBB
global box
# Lag detection
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime
delay = lag.nsecs
if print_delay:
print("delay ", "{:.3f}".format(delay / 1.0E9))
if delay > atraso and check_delay:
print("Descartando por causa do delay do frame:", delay)
return None
try:
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
media_cor, centro_cor, area_cor = cormodule.identifica_cor(cv_image)
if detect_mode:
centro, imagem, resultados = visao_module.processa(cv_image)
viu_obj = False
resultados = [i for i in resultados if i[0] == objeto]
# Procura pelo objeto
for r in resultados:
# if r[0] == objeto:
viu_obj = True
# Dimensoes do objeto
x0_obj, y0_obj = r[2]
x1_obj, y1_obj = r[3]
posicao_obj = (int(
(x0_obj + x1_obj) / 2.0), int((y0_obj + y1_obj) / 2.0))
# Dimensoes da imagem
x_obj, y_obj = posicao_obj
centro_imagem_x = res_x / 2.0
dist_obj_centro_imagem_x = x_obj - centro_imagem_x
if viu_obj:
contador_objeto += 1
if contador_objeto >= 5:
detect_mode = False
contador_objeto = 0
(x1, y1), (x2, y2) = resultados[0][2:]
initBB = (x1, y1, x2, y2)
tracker.init(cv_image, initBB)
print("\n\nTracking\n\n")
else:
contador_objeto = 0
if not detect_mode:
# TRACKER AQUI
if initBB is not None: # TODO
# grab the new bounding box coordinates of the object
(success, box_) = tracker.update(cv_image)
if success: # check to see if the tracking was a success
viu_obj = True
# print("B", box_)
box = [int(v) for v in box_]
(x, y, w, h) = box
cv2.rectangle(cv_image, (x, y), (x + w, y + h),
(255, 255, 0), 2)
else:
detect_mode = True
else:
detect_mode = True
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
print("frame")
global cv_image
global media
global centro
global viu_objeto
global centro_mnet
global resultados
global count_frame
global initBB
global x1, x2, y1, y2
global tracker
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now-imgtime # calcula o lag
delay = lag.nsecs
#print("delay ", "{:.3f}".format(delay/1.0E9))
if delay > atraso and check_delay==True:
print("Descartando por causa do delay do frame:", delay)
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
media, centro, area = cormodule.identifica_cor(cv_image)
centro_mnet, imagem, resultados = visao_module.processa(cv_image)
for r in resultados:
if r[0] == objeto:
viu_objeto = True
else:
viu_objeto = False
#######
#Código para funcionamento do tracking
if count_frame < 5:
if len(resultados) != 0:
if viu_objeto:
count_frame += 1
else:
count_frame = 0
else:
if len(resultados) !=0:
x1 = resultados[0][2][0]
y1 = resultados[0][2][1]
x2 = resultados[0][3][0]
y2 = resultados[0][3][1]
difx = x2 - x1
dify = y2 - y1
initBB = (x1, y1, abs(difx), abs(dify))
tracker.init(cv_image, initBB)
fps = FPS().start()
if initBB is not None:
# grab the new bounding box coordinates of the object
(success, box) = tracker.update(cv_image)
# check to see if the tracking was a success
if success:
(x, y, w, h) = [int(v) for v in box]
cv2.rectangle(cv_image, (x, y), (x + w, y + h),
(0, 255, 0), 2)
# update the FPS counter
fps.update()
fps.stop()
#######
depois = time.clock()
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def processa_frame(self, frame):
self.media, self.centro, self.area = cormodule.identifica_cor(
frame, self.debug)
def roda_todo_frame(imagem): #função usada pelo subscriber recebe_imagem
global cv_image
global centro
global media_vermelho
global area_vermelho
global media_azul
global area_azul
global results
global tracking
global contador
global centro_tracking
global fps
global initBB
global area_tracking
global WIDTH
global HEIGTH
now = rospy.get_rostime()
imgtime = imagem.header.stamp
lag = now - imgtime
delay = lag.secs
if delay > atraso and check_delay == True:
return
try:
antes = time.clock()
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
centro, media_vermelho, area_vermelho, media_azul, area_azul = cm.identifica_cor(
cv_image)
WIDTH, HEIGTH, g = cv_image.shape
if tracking == NADA:
results = mb.detect(cv_image, alvo)
else:
tracking_update()
if len(results) > 0:
contador += 1
else:
contador = 0
if contador > 3:
tracking = TRACKING
pi_x = results[0][2][0]
pi_y = results[0][2][1]
pf_x = results[0][3][0]
pf_y = results[0][3][1]
w = pf_x - pi_x
h = pf_y - pi_y
centro_x = pi_x + w / 2
centro_y = pi_y + h / 2
area_tracking = w * h
centro_tracking = (centro_x, centro_y)
initBB = (pi_x, pi_y, w, h)
tracker.init(cv_image, initBB)
fps = FPS().start()
results = []
tracking_update()
depois = time.clock()
cv2.imshow("Camera", cv_image)
except CvBridgeError as e:
print('ex', e)
def roda_todo_frame(imagem):
"""
Funcao com o objetivo de processar as imagens obtidas pela
camera do robo, na seguinte ordem:
1. Processa copia da imagem da camera, usando a funcao procesa_imagem_pista()
do arquivo processaImg.py. Atribui os valores retornados pela funcao
as variaveis global centro_pista, local antolho e local mask. Mostra a mask;
1a. global centro_pista: coordenadas do centro de massa da linha
amarela, que sao as coordenadas do centro da pista.
1b. local antolho: copia da imagem da camera do robo, com
retangulos desenhados por cima, que servem como antolhos,
para o robo. (Usado para fins de teste)
1c. local mask: mascara das linhas amarelas.
2. Processa copia da imagem da camera, usando a funcao identifica_cor()
do arquivo cormodule.py. Atribui os valores retornados pela funcao
as variaveis global media_creep, global maior_area e local frame;
2a. global media_creep: coordenadas do centro de massa do creeper,
que sao as coordenadas do centro do creeper.
2b. global maior_area: area do contorno do creeper mais proximo.
2c. local frame: copia da imagem da camera do robo, com o contorno
do creeper mais proximo desenhado por cima.
3. Processa copia da imagem da camera, usando a funcao aruco_read()
do arquivo processaImg.py(). Atribui os valores retornados pela funcao
as variaveis local aruco_imshow e global ids. Mostra a aruco_imshow;
3a. local aruco_imshow: copia da imagem da camera do robo, com
o contorno dos QRcodes desenhados por cima, e com os IDs dos
QRcodes sobrescritos na imagem.
3b. global ids: lista dos IDs dos QRcodes, que a funcao esta
detectando na imagem.
4. Calcula as coordenadas do centro da imagem obtida pela camera
do robo e as armazena na variavel global centro_robo;
5. Desenha uma crosshair, com as coordenadas do centro da pista,
sobre a imagem local frame. Mostra a imagem frame.
"""
global cv_image
global media
global centro_pista
global resultados
global centro_robo
global media_creep
global maior_area
global ids
try:
cv_image = bridge.compressed_imgmsg_to_cv2(imagem, "bgr8")
img_copy = cv_image.copy()
img_copy_pista = cv_image.copy()
img_copy_aruco = cv_image.copy()
img_copy_cor = cv_image.copy()
centro_pista, antolho, mask = procImg.procesa_imagem_pista(
img_copy_pista)
# cv2.imshow("antolho", antolho)
cv2.imshow("mask", mask)
media_creep, maior_area, frame = cormodule.identifica_cor(
img_copy_cor, goal1[0])
aruco_imshow, ids = procImg.aruco_read(img_copy_aruco)
cv2.imshow('aruco', aruco_imshow)
centro_robo = (img_copy.shape[1] // 2, img_copy.shape[0] // 2)
if centro_pista is not None:
crosshair(frame, centro_pista, 4, (0, 0, 255))
# cv2.imshow("cv_image", cv_image)
cv2.imshow("cor", frame)
cv2.waitKey(1)
except CvBridgeError as e:
print('ex', e)
