import numpy as np
from termcolor import colored
import timeit
import thread
import imutils
import time
import mss
import cv2
import os
import signal
import sys
import pynput
import ctypes
import pyautogui
from lib.grab import grab_screen
import matplotlib.pyplot as plt

import win32gui
import win32api
import win32con
import mouse
import keyboard

sct = mss.mss()
Wd, Hd = sct.monitors[1]["width"], sct.monitors[1]["height"]
SendInput = ctypes.windll.user32.SendInput
PUL = ctypes.POINTER(ctypes.c_ulong)

class KeyBdInput(ctypes.Structure):
    fields = [("wVk", ctypes.c_ushort),
                ("wScan", ctypes.c_ushort),
                ("dwFlags", ctypes.c_ulong),
                ("time", ctypes.c_ulong),
                ("dwExtraInfo", PUL)]
class HardwareInput(ctypes.Structure):
    fields = [("uMsg", ctypes.c_ulong),
                ("wParamL", ctypes.c_short),
                ("wParamH", ctypes.c_ushort)]
class MouseInput(ctypes.Structure):
    fields = [("dx", ctypes.c_long),
                ("dy", ctypes.c_long),
                ("mouseData", ctypes.c_ulong),
                ("dwFlags", ctypes.c_ulong),
                ("time", ctypes.c_ulong),
                ("dwExtraInfo", PUL)]
class Input_I(ctypes.Union):
    fields = [("ki", KeyBdInput),
                ("mi", MouseInput),
                ("hi", HardwareInput)]
class Input(ctypes.Structure):
    fields = [("type", ctypes.c_ulong),
                ("ii", Input_I)]

def set_pos(x, y):
   if mouse.is_pressed(button='left') or keyboard.is_pressed('alt'):
        x = int(x - (Wd / 2))
        y = int(y - (Hd / 2))

        extra = ctypes.c_ulong(0)
        ii = pynput.util.win32.INPUT_union()
        ii.mi = pynput._util.win32.MOUSEINPUT(x, y, 0, (0x0001 | 0x8000), 0, ctypes.cast(ctypes.pointer(extra), ctypes.c_void_p))
        command = pynput.util.win32.INPUT(ctypes.c_ulong(0), ii)
        SendInput(1, ctypes.pointer(command), ctypes.sizeof(command))

if __name__ == "__main__":
    print("Do not run this file directly.")

def capture_screen(region):
    with mss.mss() as sct:
        frame = np.array(sct.grab(region))
        return cv2.cvtColor(frame, cv2.COLOR_BGRA2BGR)

def process_frame(frame, net, ln):
    frame = imutils.resize(frame, width=400)
    
    blob = cv2.dnn.blobFromImage(frame, 1/255.0, (416, 416), swapRB=True, crop=False)
    net.setInput(blob)
    return net.forward(ln)

def start(ENABLE_AIMBOT):
    YOLO_DIRECTORY = "models"
    CONFIDENCE = 0.20
    THRESHOLD = 0.01
    ACTIVATION_RANGE = 200

    labelsPath = os.path.sep.join([YOLO_DIRECTORY, "obj.names"])
    LABELS = open(labelsPath).read().strip().split("\n")

    np.random.seed(42)
    COLORS = np.random.randint(0, 255, size=(len(LABELS), 3), dtype="uint8")

    weightsPath = os.path.sep.join([YOLO_DIRECTORY, "PESOCNN/yolov4-tiny-obj_final.weights"])
    configPath = os.path.sep.join([YOLO_DIRECTORY, "PESOCNN/yolov4-tiny-obj.cfg"])

    time.sleep(0.4)

    print("[INFO] loading neural-network from disk…")
    net = cv2.dnn.readNetFromDarknet(configPath, weightsPath)
    net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)
    net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)

    ln = net.getLayerNames()
    ln = [ln[i - 1] for i in net.getUnconnectedOutLayers()]

    print("[INFO] loading screencapture device…")

    W, H = None, None
    origbox = (
        int(Wd/2 - ACTIVATION_RANGE/2),
        int(Hd/2 - ACTIVATION_RANGE/2),
        int(Wd/2 + ACTIVATION_RANGE/2),
        int(Hd/2 + ACTIVATION_RANGE/2)
    )

    if not ENABLE_AIMBOT:
        print("[INFO] aimbot disabled, using visualizer only…")
    else:
        print(colored("[OKAY] Aimbot enabled!", "green"))

    def signal_handler(sig, frame):
        print("\n[INFO] cleaning up…")
        sct.close()
        cv2.destroyAllWindows()
        sys.exit(0)
    signal.signal(signal.SIGINT, signal_handler)

    build_info = str("".join(cv2.getBuildInformation().split()))
    if cv2.ocl.haveOpenCL():
        cv2.ocl.setUseOpenCL(True)
        cv2.ocl.useOpenCL()
        print(colored("[OKAY] OpenCL is working!", "green"))
    else:
        print(colored("[WARNING] OpenCL acceleration is disabled!", "yellow"))
    if "CUDA:YES" in build_info:
        print(colored("[OKAY] CUDA is working!", "green"))
    else:
        print(colored("[WARNING] CUDA acceleration is disabled!", "yellow"))

    print()

    while True:
        start_time = timeit.default_timer()

        capture_thread = threading.Thread(target=capture_screen, args=(origbox,))
        capture_thread.start()
        capture_thread.join()

        frame = capture_screen(origbox) # Substituir esta linha pelo retorno da thread no vindo da captura de tela

        layerOutputs = process_frame(frame, net, ln)

        boxes = []
        confidences = []
        classIDs = []

        for output in layerOutputs:
            for detection in output:
                scores = detection[5:] 
                classID = 0  
                confidence = scores[classID]

                if confidence > CONFIDENCE:
                    box = detection[0: 4] * np.array([W, H, W, H])
                    (centerX, centerY, width, height) = box.astype("int")

                    x = int(centerX - (width / 2))
                    y = int(centerY - (height / 2))

                    boxes.append([x, y, int(width), int(height)])
                    confidences.append(float(confidence))
                    classIDs.append(classID)

        idxs = cv2.dnn.NMSBoxes(boxes, confidences, CONFIDENCE, THRESHOLD)

        if len(idxs) > 0:
            bestMatch = confidences[np.argmax(confidences)]

            for i in idxs.flatten():
                (x, y) = (boxes[i][0], boxes[i][1])
                (w, h) = (boxes[i][2], boxes[i][3])

                cv2.circle(frame, (int(x + w / 2), int(y + h / 3)), 2, (0, 0, 255), -1)

                cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 1)

                text = "enemy {}%".format(int(confidences[i] * 100))
                cv2.putText(frame, text, (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

                if ENABLE_AIMBOT and bestMatch == confidences[i]:
                    mouseX = origbox[0] + (x + w/1.55)
                    mouseY = origbox[1] + (y + h/2.50)
                    set_pos(mouseX, mouseY)

        cv2.imshow("Neural Net Vision (Pine)", frame)
        elapsed = timeit.default_timer() - start_time
        sys.stdout.write(
            "\r{1} FPS with {0} MS interpolation delay \t".format(int(elapsed*1000), int(1/elapsed)))
        sys.stdout.flush()
        if cv2.waitKey(1) & 0xFF == ord('0'):
            break

    signal_handler(0, 0)

esta com esse erro abaixo:


[INFO] press '0' to quit or ctrl+C in console...
[INFO] loading neural-network from disk…
[INFO] loading screencapture device…
[OKAY] Aimbot enabled!
[OKAY] OpenCL is working!
[WARNING] CUDA acceleration is disabled!

Traceback (most recent call last):
  File "C:\Users\Wendel\Desktop\Apex_Aimbot_PY\teste\pine.py", line 14, in <module>
    pine.start(ENABLE_AIMBOT=True)
  File "C:\Users\Wendel\Desktop\Apex_Aimbot_PY\teste\lib\pine.py", line 144, in start
    capture_thread = threading.Thread(target=capture_screen, args=(origbox,))
                     ^^^^^^^^^
NameError: name 'threading' is not defined. Did you mean: 'thread'? Or did you forget to import 'threading'?