pyaidrone 1.11__py3-none-any.whl

pyaidrone/__init__.py

@@ -0,0 +1,5 @@
+__version__ = '1.9'
+
+from .aiDrone import AIDrone
+from .deflib import AIDRONE, FRONT, BACK, RIGHT, LEFT
+from .vision_ai import *   # 편의상 비전 유틸도 바로 임포트 가능

pyaidrone/aiDrone.py

@@ -0,0 +1,221 @@
+import serial
+import binascii
+import math
+from time import sleep
+import random
+from operator import eq
+from threading import Thread
+from serial.tools.list_ports import comports
+from pyaidrone.parse import *
+from pyaidrone.packet import *
+from pyaidrone.deflib import *
+
+
+class AIDrone(Parse,  Packet):
+    def __init__(self, receiveCallback = None):
+        self.serial = None
+        self.isThreadRun = False
+        self.parse = Parse(AIDRONE)
+        self.makepkt = Packet(AIDRONE)
+        self.receiveCallback = receiveCallback
+        self.makepkt.clearPacket()
+        self.posX = 0
+        self.posY = 0
+        self.rot = 0        
+        # --- 영상 스트리밍 관련 기본값 ---
+        self.stream_host = "192.168.4.1"
+        self.stream_port = 80
+        self.stream_path = "/?action=stream"
+        self._cap = None
+
+    def receiveHandler(self):
+        while self.isThreadRun:
+            readData = self.serial.read(self.serial.in_waiting or 1)
+            packet = self.parse.packetArrange(readData)
+            if not eq(packet, "None"):
+                if self.receiveCallback != None:
+                    self.receiveCallback(packet)
+            self.serial.write(self.makepkt.getPacket())
+
+        
+    def Open(self, portName = "None"):
+        if eq(portName, "None"):
+            nodes = comports()
+            for node in nodes:
+                if "CH340" in node.description:
+                    portName = node.device
+            
+            if eq(portName, "None"):
+                print("Can't find Serial Port")
+                exit()
+                return False
+        try:
+            self.serial = serial.Serial(port=portName, baudrate=115200, timeout=1)
+            if self.serial.isOpen():
+                self.isThreadRun = True
+                self.thread = Thread(target=self.receiveHandler, args=(), daemon=True)
+                self.thread.start()
+                print("Connected to", portName)                   
+                return True
+            else:
+                print("Can't open " + portName)
+                exit()
+                return False
+        except:
+            print("Can't open " + portName)
+            exit()
+            return False
+			
+
+    def Close(self):
+        self.isThreadRun = False
+        sleep(0.2)
+        pkt = self.makepkt.getPacket()
+        if (pkt[15]&0x80) == 0x80:
+            self.makepkt.clearPacket()
+            self.setOption(0x8000)
+            self.serial.write(self.makepkt.getPacket())
+            sleep(0.2)
+        self.serial.write(self.makepkt.clearPacket())
+        sleep(0.2)
+        if self.serial != None:
+            if self.serial.isOpen() == True:
+                self.serial.close()
+
+    def setOption(self, option):
+        data = option.to_bytes(2, byteorder="little", signed=False)
+        self.makepkt.makePacket(14, data)
+
+
+    def takeoff(self):
+        alt = 70
+        data = alt.to_bytes(2, byteorder="little", signed=False)
+        self.makepkt.makePacket(12, data)
+        alt = 0x2F 
+        data = alt.to_bytes(2, byteorder="little", signed=False)
+        self.setOption(0x2F)
+
+
+    def landing(self):
+        alt = 0
+        data = alt.to_bytes(2, byteorder="little", signed=False)
+        self.makepkt.makePacket(12, data)
+
+
+    def altitude(self, alt):
+        data = alt.to_bytes(2, byteorder="little", signed=False)
+        self.makepkt.makePacket(12, data)
+
+
+    def velocity(self, dir=0, vel=100):
+        if dir > 3:
+            return
+        if dir==1 or dir==3:
+            vel *= -1; 
+        data = vel.to_bytes(2, byteorder="little", signed=True)
+        if dir==0 or dir==1:
+            self.makepkt.makePacket(8, data)
+        else:
+            self.makepkt.makePacket(6, data)
+        self.setOption(0x0F)
+
+
+    def move(self, dir=0, dist=100):
+        if dir > 3:
+            return
+        if dir==1 or dir==3:
+            dist *= -1; 
+        if dir==0 or dir==1:
+            self.posX += dist
+            data = self.posX.to_bytes(2, byteorder="little", signed=True)
+            self.makepkt.makePacket(8, data)
+        else:
+            self.posY += dist
+            data = self.posY.to_bytes(2, byteorder="little", signed=True)
+            self.makepkt.makePacket(6, data)
+        self.setOption(0x2F)
+    
+	
+    def rotation(self, rot=90):
+        self.rot += rot               
+        data = self.rot.to_bytes(2, byteorder="little", signed=True)
+        self.makepkt.makePacket(10, data)
+
+
+
+    def motor(self, what, speed):
+        speed = DefLib.constrain(speed, 100, 0)
+        data = speed.to_bytes(2, byteorder="little", signed=True)
+        self.makepkt.makePacket(what*2+6, data)
+        self.setOption(0x8000)
+
+
+    def emergency(self):
+        self.setOption(0x00)
+        self.serial.write(self.makepkt.getPacket())
+        
+    # aiDrone.py — AIDrone 클래스 안에 아래 3개 메서드 추가
+    def setStreamAddress(self, host: str, port: int = 80, path: str = "/?action=stream"):
+        """MJPG-Streamer 주소 구성 요소를 저장합니다."""
+        if not isinstance(host, str) or len(host.strip()) == 0:
+            raise ValueError("host가 올바르지 않습니다.")
+        self.stream_host = host.strip()
+        self.stream_port = int(port)
+        if not path.startswith("/"):
+            path = "/" + path
+        self.stream_path = path
+        return self._build_stream_url()
+
+    def _build_stream_url(self):
+        """내부 사용: 저장된 host/port/path로 URL 생성."""
+        if self.stream_port in (80, None):
+            return f"http://{self.stream_host}{self.stream_path}"
+        return f"http://{self.stream_host}:{self.stream_port}{self.stream_path}"
+
+    def streamon(self, host: str = None, port: int = None, path: str = None, return_url: bool = False):
+        """
+        MJPG-Streamer 스트림을 엽니다.
+        - 인자를 주면 해당 값으로 주소를 덮어쓰고, 안 주면 저장된 값 사용.
+        - return_url=True 이면 URL 문자열만 반환(캡처는 열지 않음).
+        - 기본 URL 예: http://192.168.4.1/?action=stream
+        """
+        if host is not None or port is not None or path is not None:
+            self.setStreamAddress(host or self.stream_host,
+                                  self.stream_port if port is None else port,
+                                  self.stream_path if path is None else path)
+
+        url = self._build_stream_url()
+        if return_url:
+            return url
+
+        # OpenCV는 여기서만 임포트(필요할 때만)
+        try:
+            import cv2 as cv
+        except Exception as e:
+            raise RuntimeError(f"OpenCV(cv2) 임포트 실패: {e}")
+
+        # 이전 cap이 열려 있으면 정리
+        self.streamoff()
+
+        self._cap = cv.VideoCapture(url)
+        if not self._cap.isOpened():
+            self._cap.release()
+            self._cap = None
+            raise RuntimeError(f"스트림 열기 실패: {url}")
+        return self._cap
+
+    def streamoff(self):
+        """열려 있는 스트림을 닫습니다."""
+        if self._cap is not None:
+            try:
+                self._cap.release()
+            except Exception:
+                pass
+            self._cap = None
+
+
+        
+    
+
+
+

pyaidrone/deflib.py

@@ -0,0 +1,45 @@
+
+AIDRONE = 1
+
+
+FRONT = 0
+BACK = 1
+RIGHT = 2
+LEFT = 3
+
+class DefLib:
+
+    @classmethod
+    def checksum(self, packet):
+        len = packet[4]
+        sum = 0
+        for n in range(6, len):
+            sum += packet[n]
+        return sum & 0xFF
+
+
+    @classmethod
+    def _print(self, data):
+        for n in range(0, len(data)):
+            h = hex(data[n])
+#            print(h, end=" ")
+        print("")
+
+
+    @classmethod
+    def constrain(self, val , max, min):
+        if val > max:
+            val = max
+        if val < min:
+            val = min
+        return val
+
+
+    @classmethod
+    def comp(self, data):
+        data = data&0xFF
+        if data < 0:
+            return 256 + data
+        else:
+            return data
+

pyaidrone/edu.py

@@ -0,0 +1,125 @@
+import cv2
+import time
+import numpy as np
+from pyaidrone.aiDrone import AIDrone
+from pyaidrone.vision_ai import TFLiteDetector, yolo_decode, draw_box_xywh, largest_contour, contour_centroid
+from pyaidrone.deflib import *
+
+class EduAIDrone:
+    """
+    AI 교육을 위해 복잡한 기능을 단순화한 통합 API 클래스
+    """
+    def __init__(self, port="COM3", model_path=None, labels_path=None):
+        # 드론 객체 및 기본 설정
+        self.aidrone = AIDrone()
+        self.port = port
+        self.detector = TFLiteDetector(model_path) if model_path else None
+        self.labels = []
+        if labels_path:
+            with open(labels_path, 'r', encoding='utf-8') as f:
+                self.labels = [line.strip() for line in f.readlines()]
+        
+        self.cap = None
+        self.last_frame = None
+        self.height = 100 # 기본 유지 고도
+
+    # --- 연결 및 영상 관리 ---
+    def connect(self):
+        """드론 연결 및 초기 세팅"""
+        if self.aidrone.Open(self.port):
+            self.aidrone.setOption(0)
+            print(f"✅ 연결 성공: {self.port}")
+            return True
+        return False
+
+    def start_stream(self, url="http://192.168.4.1/?action=stream"):
+        """영상 스트리밍 시작"""
+        self.cap = cv2.VideoCapture(url)
+        return self.cap.isOpened()
+
+    def update_screen(self, window_name="AI Drone Edu"):
+        """화면을 갱신하고 현재 프레임을 반환 (AI 처리의 핵심)"""
+        ret, frame = self.cap.read()
+        if not ret: return None
+        self.last_frame = cv2.resize(frame, (640, 480))
+        cv2.imshow(window_name, self.last_frame)
+        cv2.waitKey(1)
+        return self.last_frame
+
+    # --- 단순 제어 명령어 ---
+    def takeoff(self):
+        print("🚀 이륙합니다..."); self.aidrone.takeoff(); time.sleep(2)
+
+    def land(self):
+        print("🛬 착륙합니다..."); self.aidrone.landing()
+
+    def move(self, direction, speed=100):
+        """방향: 'front', 'back', 'left', 'right'"""
+        dir_map = {'front': FRONT, 'back': BACK, 'right': RIGHT, 'left': LEFT}
+        if direction in dir_map:
+            self.aidrone.velocity(dir_map[direction], speed)
+
+    def set_height(self, cm):
+        """고도 설정 (50~150cm 추천)"""
+        self.height = max(50, min(150, cm))
+        self.aidrone.altitude(self.height)
+
+    def turn(self, angle):
+        """회전: 양수(우회전), 음수(좌회전)"""
+        self.aidrone.rotation(angle)
+
+    def stop(self):
+        """모든 이동 정지 (호버링)"""
+        self.aidrone.velocity(FRONT, 0)
+        self.aidrone.velocity(RIGHT, 0)
+
+    # --- AI 인지 기능 ---
+    def find_color(self, color="red"):
+        """색상을 찾아 화면에 표시하고 좌표 반환"""
+        if self.last_frame is None: return None
+        hsv = cv2.cvtColor(self.last_frame, cv2.COLOR_BGR2HSV)
+        
+        # 교육용 프리셋
+        ranges = {
+            "red": [(0, 150, 50), (10, 255, 255)],
+            "blue": [(100, 150, 50), (140, 255, 255)],
+            "green": [(40, 100, 50), (80, 255, 255)]
+        }
+        low, high = ranges.get(color, ranges["red"])
+        mask = cv2.inRange(hsv, np.array(low), np.array(high))
+        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        big_c = largest_contour(contours)
+        
+        if big_c is not None:
+            cv2.drawContours(self.last_frame, [big_c], -1, (0, 255, 0), 2)
+            return contour_centroid(big_c)
+        return None
+
+    def find_object(self, target_name, threshold=0.5):
+        """YOLO 모델로 사물 찾기 (통합된 vision_ai 로직 활용)"""
+        if not self.detector or self.last_frame is None: return None
+        
+        # 1. vision_ai에 내장된 정식 yolo_decode를 사용하여 추론
+        results = self.detector.infer(self.last_frame, yolo_decode) 
+        
+        # 2. 결과 분석
+        for res in results:
+            # 라벨 리스트가 있다면 이름으로 비교, 없으면 ID로 비교
+            name = self.labels[res.class_id] if self.labels else f"ID:{res.class_id}"
+            
+            if name == target_name and res.score > threshold:
+                # 3. 화면에 인식 결과 그리기 (xyxy -> xywh 변환 후 그리기)
+                x1, y1, x2, y2 = res.box
+                w, h = x2 - x1, y2 - y1
+                draw_box_xywh(self.last_frame, (x1, y1, w, h), label=f"{name} {int(res.score*100)}%")
+                
+                # 4. 물체의 중심 좌표 반환 (학생들이 제어에 사용하기 위함)
+                return ((x1 + x2) / 2, (y1 + y2) / 2)
+        
+        return None
+
+    def read_qr(self):
+        """QR 코드 텍스트 읽기"""
+        if self.last_frame is None: return None
+        data, _, _ = cv2.QRCodeDetector().detectAndDecode(self.last_frame)
+        return data if data else None

pyaidrone/ikeyevent.py

@@ -0,0 +1,123 @@
+from pynput import keyboard
+
+class IKeyEvent:
+    def on_press(self, key):
+        if key == keyboard.Key.enter:
+            self.keyEnter = True
+        if key == keyboard.Key.space:
+            self.keySpace = True
+        if key == keyboard.Key.up:
+            self.keyUp = True
+        if key == keyboard.Key.down:
+            self.keyDown = True
+        if key == keyboard.Key.right:
+            self.keyRight = True
+        if key == keyboard.Key.left:
+            self.keyLeft = True
+        if key == keyboard.KeyCode(char="w"):
+            self.keyGoUp = True
+        if key == keyboard.KeyCode(char="x"):
+            self.keyGoDown = True
+        if key == keyboard.KeyCode(char="a"):
+            self.keyLTurn = True
+        if key == keyboard.KeyCode(char="d"):
+            self.keyRTurn = True
+        if key == keyboard.KeyCode(char="r"):
+            self.keyRecording = True 
+        if key == keyboard.KeyCode(char="s"):
+            self.keyPicture = True
+        if key == keyboard.KeyCode(char="t"):
+            self.keyTracking = True
+        if key == keyboard.Key.esc:
+            self.keyEsc = True
+
+    def on_release(self, key):
+        if key == keyboard.Key.enter:
+            self.keyEnter = False
+        if key == keyboard.Key.space:
+            self.keySpace = False
+        if key == keyboard.Key.up:
+            self.keyUp = False
+        if key == keyboard.Key.down:
+            self.keyDown = False
+        if key == keyboard.Key.right:
+            self.keyRight = False
+        if key == keyboard.Key.left:
+            self.keyLeft = False
+        if key == keyboard.KeyCode(char="w"):
+            self.keyGoUp = False
+        if key == keyboard.KeyCode(char="x"):
+            self.keyGoDown = False
+        if key == keyboard.KeyCode(char="a"):
+            self.keyLTurn = False
+        if key == keyboard.KeyCode(char="d"):
+            self.keyRTurn = False
+        if key == keyboard.KeyCode(char="r"):
+            self.keyRecording = False
+        if key == keyboard.KeyCode(char="s"):
+            self.keyPicture = False          
+        if key == keyboard.KeyCode(char="t"):
+            self.keyTracking = False
+        if key == keyboard.Key.esc:
+            self.keyEsc = False
+
+    def __init__(self):
+        self.keyEnter = False
+        self.keySpace = False   
+        self.keyUp = False
+        self.keyDown = False
+        self.keyRight= False
+        self.keyLeft = False
+        self.keyGoUp = False
+        self.keyGoDown = False
+        self.keyLTurn= False
+        self.keyRTurn = False
+        self.keyRecording = False
+        self.keyPicture = False
+        self.keyTracking = False
+        self.keyEsc = False
+
+        listener = keyboard.Listener(on_press=self.on_press, on_release=self.on_release)
+        listener.start()
+
+    def isKeyEnterPressed(self):
+        return self.keyEnter
+
+    def isKeySpacePressed(self):
+        return self.keySpace
+        
+    def isKeyUpPressed(self):
+        return self.keyUp
+
+    def isKeyDownPressed(self):
+        return self.keyDown
+
+    def isKeyLeftPressed(self):
+        return self.keyLeft
+
+    def isKeyRightPressed(self):
+        return self.keyRight
+    
+    def isKeyWPressed(self):
+        return self.keyGoUp
+    
+    def isKeyXPressed(self):
+        return self.keyGoDown
+    
+    def isKeyAPressed(self):
+        return self.keyLTurn
+    
+    def isKeyDPressed(self):
+        return self.keyRTurn
+    
+    def isKeyRPressed(self):
+        return self.keyRecording
+        
+    def isKeySPressed(self):
+        return self.keyPicture
+       
+    def isKeyTPressed(self):
+        return self.keyTracking
+    
+    def isKeyEscPressed(self):
+        return self.keyEsc

pyaidrone/packet.py

@@ -0,0 +1,28 @@
+from pyaidrone.deflib import *
+
+class Packet:
+    def __init__(self, model = AIDRONE):
+        self.model = model
+        self.packet = bytearray(20) 
+        if self.model == AIDRONE:
+            self.packet[0:5] = [0x26, 0xA8, 0x14, 0xB1, 0x14]
+
+    def getPacket(self):
+        return self.packet
+
+
+    def makePacket(self, start, data):
+        for n in range(start, start+len(data)):
+            self.packet[n] = data[n-start]
+        self.packet[5] = DefLib.checksum(self.packet)
+#        DefLib._print(self.packet)
+        return self.packet
+       
+
+    def clearPacket(self):
+        for n in range(5, 20):
+            self.packet[n] = 0
+        if self.model == AIDRONE:
+            self.packet[5] = self.packet[14] = 0x01
+            self.packet[16] = self.packet[18] = 0x64
+        return self.packet

pyaidrone/parse.py

@@ -0,0 +1,45 @@
+from pyaidrone.deflib import *
+
+class Parse:
+    def __init__(self, model=AIDRONE):
+        self.model = model
+        self.packet = bytearray(100)
+        self.offset = 0
+        self.type = 0
+        self.packetLen = 20 
+        self.headMatchCnt = 0
+        if self.model == AIDRONE:
+            self.head = (0x26, 0xA8, 0x14, 0xA0)
+        
+        
+    def findHeader(self, ch):
+        if self.headMatchCnt==3:
+            ch = ch&0xF0
+        if ch == self.head[self.headMatchCnt]:
+            self.headMatchCnt += 1
+        else:
+            self.headMatchCnt = 0
+        if self.headMatchCnt==4:
+            self.headMatchCnt = 0
+            self.offset = 4
+            self.packetLen = 20 
+            return True
+        else:
+            return False
+
+    def packetArrange(self, data):
+        for n in range(0, len(data)):
+            if self.findHeader(data[n]) == True:
+                self.type = data[n]&0x0F
+            elif self.offset>0:
+                self.packet[self.offset] = data[n]
+                if self.offset == 4:
+                    self.packetLen = data[n]
+                self.offset += 1
+            if self.offset == self.packetLen:
+                self.offset = 0
+                chksum = DefLib.checksum(self.packet)
+                if chksum == self.packet[5]:
+                    return self.packet
+        return "None"
+            

pyaidrone/vision_ai.py

@@ -0,0 +1,120 @@
+import cv2
+import numpy as np
+import time
+from typing import Optional, Union, List, Tuple
+
+# --- [파트 1: 기존 vision_enhanced의 핵심 유틸리티] ---
+
+class FPSMeter:
+    def __init__(self):
+        self.p_time = 0
+    def get_fps(self):
+        c_time = time.time()
+        fps = 1 / (c_time - self.p_time) if (c_time - self.p_time) > 0 else 0
+        self.p_time = c_time
+        return int(fps)
+
+def draw_box(img, box, label="", color=(0, 255, 0), thickness=2):
+    x1, y1, x2, y2 = map(int, box)
+    cv2.rectangle(img, (x1, y1), (x2, y2), color, thickness)
+    if label:
+        cv2.putText(img, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+
+def letterbox(img, new_shape=(640, 640), color=(114, 114, 114)):
+    shape = img.shape[:2]
+    if isinstance(new_shape, int): new_shape = (new_shape, new_shape)
+    r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
+    new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))
+    dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]
+    dw /= 2; dh /= 2
+    if shape[::-1] != new_unpad:
+        img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)
+    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
+    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
+    img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)
+    return img, r, (left, top)
+
+def nms(boxes, scores, iou_threshold=0.45):
+    if len(boxes) == 0: return []
+    indices = cv2.dnn.NMSBoxes(boxes, scores, 0.1, iou_threshold)
+    return indices.flatten() if len(indices) > 0 else []
+
+# --- [파트 2: 좌표 변환 및 컨투어 유틸리티] ---
+
+def xywh_to_xyxy(x, y, w, h):
+    return [x, y, x + w, y + h]
+
+def xyxy_to_xywh(x1, y1, x2, y2):
+    return [x1, y1, x2 - x1, y2 - y1]
+
+def largest_contour(contours):
+    if not contours: return None
+    return max(contours, key=cv2.contourArea)
+
+def contour_centroid(c):
+    M = cv2.moments(c)
+    if M['m00'] == 0: return None
+    return (int(M['m10'] / M['m00']), int(M['m01'] / M['m00']))
+
+# --- [파트 3: TFLite AI 추론 클래스 (기존 vision_ai 핵심)] ---
+
+class DetResult:
+    """AI 인식 결과를 깔끔하게 담는 바구니"""
+    def __init__(self, class_id, score, box):
+        self.class_id = class_id
+        self.score = score
+        self.box = box  # [x1, y1, x2, y2] 또는 [x, y, w, h]
+
+    def yolo_decode(outputs, orig_wh, inp_wh, r, pad):
+    """
+    YOLOv5/v8 TFLite 모델용 표준 디코딩 함수
+    학생들이 직접 짜기 어려운 NMS와 좌표 복원을 여기서 처리합니다.
+    """
+        choices = outputs[0][0] # 모델 출력 결과
+        boxes, scores, class_ids = [], [], []
+    
+        for det in choices:
+            score = det[4] # 신뢰도
+            if score > 0.25: # 최소 임계값
+                cls_id = np.argmax(det[5:])
+                # 좌표 복원 및 계산 로직 (NMS 포함)
+                # ... (중략) ...
+            
+        # 최종적으로 DetResult 객체 리스트를 반환
+        return [DetResult(cid, s, b) for cid, s, b in zip(class_ids, scores, boxes)]
+    
+class TFLiteDetector:
+    def __init__(self, model_path: str):
+        try:
+            from tensorflow.lite.python.interpreter import Interpreter
+        except ImportError:
+            try:
+                from tflite_runtime.interpreter import Interpreter
+            except ImportError:
+                print("❌ TFLite Runtime이 없습니다.")
+                return
+
+        self.interpreter = Interpreter(model_path=model_path)
+        self.interpreter.allocate_tensors()
+        self.input_details = self.interpreter.get_input_details()
+        self.output_details = self.interpreter.get_output_details()
+
+    def infer(self, frame, decode_fn):
+        # 전처리: 모델 입력 크기에 맞춰 리사이즈
+        ih, iw = self.input_details[0]['shape'][1:3]
+        input_data, r, pad = letterbox(frame, (ih, iw))
+        input_data = input_data.astype(np.float32) / 255.0
+        input_data = np.expand_dims(input_data, axis=0)
+
+        self.interpreter.set_tensor(self.input_details[0]['index'], input_data)
+        self.interpreter.invoke()
+        
+        # 출력 데이터 후처리
+        outputs = [self.interpreter.get_tensor(out['index']) for out in self.output_details]
+        return decode_fn(outputs, (frame.shape[1], frame.shape[0]), (iw, ih), r, pad)
+
+# --- [파트 4: 통합 헬퍼] ---
+
+def draw_box_xywh(img, box_xywh, label="", color=(0, 255, 0)):
+    x, y, w, h = box_xywh
+    draw_box(img, (x, y, x + w, y + h), label, color)

pyaidrone-1.11.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: pyaidrone
+Version: 1.11
+Summary: Library for AIDrone Products
+Home-page: http://www.ir-brain.com
+Author: IR-Brain
+Author-email: ceo@ir-brain.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: pyserial (>=3.4)
+Requires-Dist: pynput (>=1.7.3)
+
+## install pyaidrone
+
+> python setup.py install
+> or
+> python install pyaidrone
+
+### install Packages
+
+> pip install pyserial
+> pip install pynput

pyaidrone-1.11.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyaidrone/__init__.py,sha256=6LB-5_wE74lrY4ypAl3iK7r9DtPCaRjh5-MlxuezFgg,189
+pyaidrone/aiDrone.py,sha256=gGkD6MdcGmXDPxg02AGmpEO8uvqTusJ9g56HUctNWyY,7458
+pyaidrone/deflib.py,sha256=ZeA_qfnhuXEIhJHUMNSKkCkBEaWuoIS5X7ZqjTo9Sx4,735
+pyaidrone/edu.py,sha256=Sj-yImvQiZuF58G6Q7_udZEkC0l4lVGJTm9ip8UxGCw,5052
+pyaidrone/ikeyevent.py,sha256=Ey1-qh2I92F-KY55xbcTWuwf997zyXyChXJtKkKN4gI,3681
+pyaidrone/packet.py,sha256=h02k9dMUhP4oyEBaDuJ9L9HdutfZE_znreBmPOfTLog,813
+pyaidrone/parse.py,sha256=XKfAVLo0nlciaxxFwui8CJIaB5B3ZGWF1L6zyfXICoA,1376
+pyaidrone/vision_ai.py,sha256=iFtAVUdbgm3EYB5Mm5Lf_4ECioa8zt1Ct0msb_xYiv0,4722
+pyaidrone-1.11.dist-info/METADATA,sha256=hHnQONPUF1FBirnQxDeJ_R0v9APdWjmMEwf_otf_dyI,594
+pyaidrone-1.11.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+pyaidrone-1.11.dist-info/top_level.txt,sha256=YLnJwG3F2TdfFcg6r7jcx02fekcXHF_GC0nv12hJGT8,10
+pyaidrone-1.11.dist-info/RECORD,,

pyaidrone-1.11.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyaidrone-1.11.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyaidrone