Hi
I need to stream image to Computer Vision.
My computer is 32GB RAM.
When process has self.model & self.model.run, the process works but is killed after about 360 seconds with the reason that there is no more memory available .
But process does’t has self.model & self.model.run, memory also continuously rising.
import olympe
from olympe.messages.ardrone3.PilotingState import PositionChanged
#from olympe.messaage.ardrone3.Pilotin4g import TakeOff, moveBy, Landing, moveTo, NavigateHome
import threading
import time
import queue
import cv2
import os
from Mydetect import Detect
import argparse
import gc
class OlympeStreaming():
def __init__(self, drone, opt):
self.drone = drone
self.frame_queue = queue.Queue(3)
self.frame_num = 0
self.renderer = None
self.opt = opt
#self.model = Detect(opt=self.opt)
def start(self):
self.drone.streaming.set_callbacks(
raw_cb=self.yuv_frame_cb,
h264_cb=self.h264_frame_cb,
start_cb=self.start_cb,
end_cb=self.end_cb,
flush_raw_cb=self.flush_cb,
)
self.drone.streaming.start()
def stop(self):
if self.renderer is not None :
self.renderer.stop()
self.drone.streaming.stop()
def yuv_frame_cb(self, yuv_frame):
"""
This function will be called by Olympe for each decoded YUV frame.
:type yuv_frame: olympe.VideoFrame
"""
print('refrefrefrefrefrefrefrefrefrefrefref')
yuv_frame.ref()
if self.frame_queue.empty(): #20221027
self.frame_queue.put(yuv_frame, timeout=0.1)
else:
print('hahahahahahahahahahahahahah')
yuv_frame.unref()
def flush_cb(self, stream):
if stream["vdef_format"] != olympe.VDEF_I420:
return True
while not self.frame_queue.empty():
print('ccccccccccccccccccccccccccccccc')
self.frame_queue.get_nowait().unref()
return True
def start_cb(self):
pass
def end_cb(self):
pass
def h264_frame_cb(self, h264_frame):
pass
def display_frame(self, yuv_frame):
# the VideoFrame.info() dictionary contains some useful information
# such as the video resolution
info = yuv_frame.info()
height, width = ( # noqa
info["raw"]["frame"]["info"]["height"],
info["raw"]["frame"]["info"]["width"],
)
# yuv_frame.vmeta() returns a dictionary that contains additional
# metadata from the drone (GPS coordinates, battery percentage, ...)
# convert pdraw YUV flag to OpenCV YUV flag
cv2_cvt_color_flag = {
olympe.VDEF_I420: cv2.COLOR_YUV2BGR_I420,
olympe.VDEF_NV12: cv2.COLOR_YUV2BGR_NV12,
}[yuv_frame.format()]
#yuv_frame.as_ndarray() is a 2D numpy with the proper "shape"
# i.e (3 * height / 2, width) because it's a YUV I420 or NV12 frame
GPS = self.drone.get_state(PositionChanged)
cv2frame = cv2.cvtColor(yuv_frame.as_ndarray(), cv2_cvt_color_flag)
#self.model.run(image=cv2frame, GPS = GPS)
#cv2.imshow("frames via Olympe", cv2frame)
#cv2.waitKey(1)
del GPS
del cv2frame
#cv2.destroyAllWindows()
def run(self):
#main_thread = next(filter(lambda t : t.name == "MainThread", threading.enumerate()))
while True:
try:
yuv_frame = self.frame_queue.get(timeout=0.01)
except queue.Empty:
continue
try:
self.display_frame(yuv_frame)
except Exception as e:
print(e)
finally:
yuv_frame.unref()
#logger = logging.getLogger(name)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument('--weights', nargs='+', type=str, default='yolov7.pt', help='model.pt path(s)')
parser.add_argument('--source', type=str, default='inference/images', help='source') # file/folder, 0 for webcam
parser.add_argument('--img-size', type=int, default=640, help='inference size (pixels)')
parser.add_argument('--conf-thres', type=float, default=0.25, help='object confidence threshold')
parser.add_argument('--iou-thres', type=float, default=0.45, help='IOU threshold for NMS')
parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
parser.add_argument('--view-img', action='store_true', help='display results')
parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
parser.add_argument('--nosave', action='store_true', help='do not save images/videos')
parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --class 0, or --class 0 2 3')
parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')
parser.add_argument('--augment', action='store_true', help='augmented inference')
parser.add_argument('--update', action='store_true', help='update all models')
parser.add_argument('--project', default='runs/detect', help='save results to project/name')
parser.add_argument('--name', default='exp', help='save results to project/name')
parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
parser.add_argument('--no-trace', action='store_true', help='don`t trace model')
opt = parser.parse_args()
print(opt)
DRONE_IP = os.environ.get("DRONE_IP", "192.168.53.1")
drone = olympe.Drone(DRONE_IP)
drone.connect()
streamer = OlympeStreaming(drone=drone, opt=opt)
streamer.start()
print('Hi')
streamer.run()
#from pynput import keyboard
#while key == keyboard.Key.esc:
##streamer.stop()
#print("stop")
#streamer.stop()
time.sleep(10000)
streamer.stop()
drone.disconnect()
How to solve?
Regards,
Tom