agrobot_base/Python/street-follower/green-detector.py

import cv2
import numpy as np
from flask import Flask, Response, request
import json
import time
import socket
import threading
import sys
import os


max_readings = int(sys.argv[1])
porta = sys.argv[2]
url = sys.argv[3]
arquivoSaida = sys.argv[4]
mostrar_linhas = sys.argv[5] == "1"
socket_porta = int(sys.argv[6])

app = Flask(__name__)

json_data = None

# Função para detecção de objetos usando YOLO e salvar as coordenadas em um arquivo JSON
def detect_objects(conf_threshold, nms_threshold, _camera_index):
    # Definir intervalos de cor verde no espaço HSV
    lower_green = np.array([35, 50, 100])  # Valores de limite inferior (Hue, Saturation, Value)
    upper_green = np.array([90, 255, 255])  # Valores de limite superior (Hue, Saturation, Value)

    cap = cv2.VideoCapture(_camera_index, cv2.CAP_DSHOW)
    readings = []

    while True:
        ret, frame = cap.read()
        if not ret:
            break

        # Converter a imagem de BGR para HSV
        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

        # Criar uma máscara para os pixels verdes na faixa especificada
        mask = cv2.inRange(hsv, lower_green, upper_green)

        # Encontrar os contornos na máscara
        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

        current_readings = []
        idx = 0  # Índice de detecção
        for contour in contours:
            area = cv2.contourArea(contour)
            if area > 1000:  # Filtrar áreas menores que um valor específico (ajuste conforme necessário)
                x, y, w, h = cv2.boundingRect(contour)
                cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
                cv2.putText(frame, f'Green {idx}', (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

                # Salvar as informações da detecção
                detection_info = {
                    'id': int(idx),
                    'descricao': 'Green',
                    'x': int(x),
                    'y': int(y),
                    'largura': int(w),
                    'altura': int(h),
                    'confianca': 1.0  # Neste caso, confiança fixa para detecções baseadas em cores
                }
                current_readings.append(detection_info)
                idx += 1

        global json_data

        # Atualizar os resultados
        timestamp = time.time()
        json_data = {'timestamp': timestamp, 'objetos': current_readings}
        readings.append(json_data)

        # Salvar as detecções em um arquivo JSON
        if len(readings) > max_readings:
            readings.pop(0)

        output_folder = 'Python/Output/'

        if not os.path.exists(output_folder):
            os.makedirs(output_folder)

        if len(readings) == max_readings:
            try:
                with open(output_folder + arquivoSaida, 'w') as file:
                    json.dump({'frames': readings}, file)
            except Exception as e:
                print(f"Erro ao escrever no arquivo: {e}")

        cv2.imshow('Deteccao de Objetos YOLO', frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

        # Convertendo frame para JPEG e enviando via Flask
        ret, buffer = cv2.imencode('.jpg', frame)
        frame = buffer.tobytes()
        yield (b'--frame\r\n'
               b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')

# Função para lidar com a conexão de cada cliente
def handle_client_connection(client_socket):
    try:
        while True:
            # Enviar o dicionário serializado em JSON
            client_socket.send(json.dumps(json_data).encode('utf-8'))

            # Aguardar um pouco antes de enviar os próximos dados
            time.sleep(0.5)
    except socket.error:
        print(f"Cliente desconectado.")
    finally:
        # Fechar a conexão do socket ao sair do loop
        client_socket.close()

# Configuração inicial do servidor de socket
def start_server(address='localhost', port=socket_porta):
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind((address, port))
    server.listen()
    print(f"Servidor iniciado. Aguardando conexões em {address}:{port}...")
    
    try:
        while True:
            client_sock, address = server.accept()
            print(f"Aceitando conexão de {address[0]}:{address[1]}")
            client_handler = threading.Thread(
                target=handle_client_connection,
                args=(client_sock,)
            )
            client_handler.start()
    finally:
        server.close()


# Esta função é para iniciar o servidor de socket em uma thread separada
def run_socket_server():
    start_server()

# Iniciar o servidor Flask em uma thread separada
def run_flask_server():
    app.run(host='0.0.0.0', port=porta, threaded=True, debug=False)

@app.route('/' + url, methods=['GET'])
def video_feed():
    conf_threshold = float(request.args.get('conf_threshold'))
    nms_threshold = float(request.args.get('nms_threshold'))
    camera_index = int(request.args.get('camera_index'))
    return Response(detect_objects(conf_threshold, nms_threshold, camera_index), mimetype='multipart/x-mixed-replace; boundary=frame')


# Iniciar o servidor
if __name__ == '__main__':
    # Inicia o servidor de socket em uma thread separada
    socket_server_thread = threading.Thread(target=run_socket_server)
    socket_server_thread.start()

    # Inicia o servidor Flask na thread principal
    run_flask_server()