def main():
global classifier, labels
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument(
'-m',
'--model',
help='File path of .tflite file. Default is vision.CLASSIFICATION_MODEL'
)
parser.add_argument(
'-l',
'--labels',
help='File path of labels file. Default is vision.CLASSIFICATION_LABELS'
)
parser.add_argument(
'-i',
'--input',
help=
'Image to be classified. If not given, use spacebar to capture an image.'
)
args = parser.parse_args()
if args.model:
classifier = vision.Classifier(args.model)
if args.labels:
labels = read_label_file(args.labels)
if args.input:
frame = imread(args.input)
classify_image(frame)
else:
classify_live()
def detect_person(image_input):
from pycoral.adapters import common
from pycoral.adapters import detect
from pycoral.utils.dataset import read_label_file
from pycoral.utils.edgetpu import make_interpreter
label_path = os.path.join(BASE_DIR, 'coral_files', 'coco_labels.txt')
model_path = os.path.join(
BASE_DIR, 'coral_files',
'ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite')
print(model_path)
image = Image.fromarray(image_input)
print(image)
labels = read_label_file(label_path)
print("labels", labels)
interpreter = make_interpreter(model_path)
print("INterpreter made")
interpreter.allocate_tensors()
print("Tensor allocated")
_, scale = common.set_resized_input(
interpreter, image.size,
lambda size: image.resize(size, Image.ANTIALIAS))
print("Before invoke")
interpreter.invoke()
objs = detect.get_objects(interpreter, 0.4, scale)
print(objs)
for obj in objs:
print(labels.get(obj.id, obj.id))
print(' id: ', obj.id)
print(' score: ', obj.score)
print(' bbox: ', obj.bbox)
return False
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--labels',
'-l',
type=str,
required=True,
help='Labels file')
parser.add_argument('--capture_dir',
'-d',
type=str,
default='capture',
help='Capture directory')
parser.add_argument('--model',
'-m',
type=str,
default=DEFAULT_BASE_MODEL,
help='Base model')
parser.add_argument('--out_model',
'-om',
type=str,
default='my-model.tflite',
help='Output model')
args = parser.parse_args()
labels = read_label_file(args.labels)
train(args.capture_dir, labels, args.model, args.out_model)
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-m',
'--model',
required=True,
help='File path of .tflite file.')
parser.add_argument('-i',
'--input',
required=True,
help='Image to be classified.')
parser.add_argument('-l', '--labels', help='File path of labels file.')
parser.add_argument('-k',
'--top_k',
type=int,
default=1,
help='Max number of classification results')
parser.add_argument('-t',
'--threshold',
type=float,
default=0.0,
help='Classification score threshold')
parser.add_argument('-c',
'--count',
type=int,
default=5,
help='Number of times to run inference')
args = parser.parse_args()
labels = read_label_file(args.labels) if args.labels else {}
interpreter = make_interpreter(*args.model.split('@'))
interpreter.allocate_tensors()
_, height, width = interpreter.get_input_details()[0]['shape']
size = [height, width]
image = Image.open(args.input).resize(size, Image.ANTIALIAS)
common.set_input(interpreter, image)
trigger = GPIO("/dev/gpiochip2", 13, "out") # pin 37
print('----INFERENCE TIME----')
print('Note: The first inference on Edge TPU is slow because it includes',
'loading the model into Edge TPU memory.')
#for _ in range(args.count):
while (1):
start = time.perf_counter()
trigger.write(True)
time.sleep(0.0005)
trigger.write(False)
#interpreter.invoke()
inference_time = time.perf_counter() - start
#classes = classify.get_classes(interpreter, args.top_k, args.threshold)
print('%.1fms' % (inference_time * 1000))
print('-------RESULTS--------')
for c in classes:
print('%s: %.5f' % (labels.get(c.id, c.id), c.score))
def detect_func():
## parser = argparse.ArgumentParser(
## formatter_class=argparse.ArgumentDefaultsHelpFormatter)
## parser.add_argument('-m', '--model', required=True,
## help='File path of .tflite file')
# parser.add_argument('-i', '--input', required=True,
# help='File path of image to process')
# parser.add_argument('-l', '--labels', help='File path of labels file')
# parser.add_argument('-t', '--threshold', type=float, default=0.4,
# help='Score threshold for detected objects')
# parser.add_argument('-o', '--output',
# help='File path for the result image with annotations')
# parser.add_argument('-c', '--count', type=int, default=5,
# help='Number of times to run inference')
# args = parser.parse_args()
labels = read_label_file('test_data/coco_labels.txt')
interpreter = make_interpreter(
'test_data/ssd_mobilenet_v2_coco_quant_postprocess.tflite')
interpreter.allocate_tensors()
image = Image.open('pic.jpg')
_, scale = common.set_resized_input(
interpreter, image.size,
lambda size: image.resize(size, Image.ANTIALIAS))
print('----INFERENCE TIME----')
print('Note: The first inference is slow because it includes',
'loading the model into Edge TPU memory.')
for _ in range(5):
start = time.perf_counter()
interpreter.invoke()
inference_time = time.perf_counter() - start
objs = detect.get_objects(interpreter, 0.4, scale)
print('%.2f ms' % (inference_time * 1000))
print('-------RESULTS--------')
if not objs:
print('No objects detected')
people_flag = 0
for obj in objs:
if obj.id == 0:
print('people detected!')
people_flag = 1
print(labels.get(obj.id, obj.id))
print(' id: ', obj.id)
print(' score: ', obj.score)
print(' bbox: ', obj.bbox)
# if args.output:
# image = image.convert('RGB')
# draw_objects(ImageDraw.Draw(image), objs, labels)
# image.save(args.output)
# image.show()
return people_flag
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
help='File path of Tflite model.',
required=True)
parser.add_argument('--labels',
help='File path of label file.',
required=True)
parser.add_argument('--picamera',
action='store_true',
help="Use PiCamera for image capture",
default=False)
parser.add_argument('-t',
'--threshold',
type=float,
default=0.5,
help='Classification score threshold')
args = parser.parse_args()
print('Loading {} with {} labels.'.format(args.model, args.labels))
labels = read_label_file(args.labels) if args.labels else {}
interpreter = make_interpreter(args.model)
interpreter.allocate_tensors()
# Initialize video stream
vs = VideoStream(usePiCamera=args.picamera, resolution=(640, 480)).start()
time.sleep(1)
fps = FPS().start()
while True:
try:
# Read frame from video
screenshot = vs.read()
image = Image.fromarray(screenshot)
_, scale = common.set_resized_input(
interpreter, image.size,
lambda size: image.resize(size, Image.ANTIALIAS))
interpreter.invoke()
objs = detect.get_objects(interpreter, args.threshold, scale)
draw_objects(image, objs, labels)
if (cv2.waitKey(5) & 0xFF == ord('q')):
fps.stop()
break
fps.update()
except KeyboardInterrupt:
fps.stop()
break
print("Elapsed time: " + str(fps.elapsed()))
print("Approx FPS: :" + str(fps.fps()))
cv2.destroyAllWindows()
vs.stop()
time.sleep(2)
def __init__(self):
super().__init__("CoralWorker")
self.interpreter = make_interpreter(
os.path.join(
ExopticonWorker.get_data_dir(),
"ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite"))
self.interpreter.allocate_tensors()
input_size = common.input_size(self.interpreter)
self.labels = read_label_file(
os.path.join(ExopticonWorker.get_data_dir(), "coco_labels.txt"))
def main():
default_model_dir = '../all_models'
default_model = 'mobilenet_ssd_v2_coco_quant_postprocess_edgetpu.tflite'
default_labels = 'coco_labels.txt'
parser = argparse.ArgumentParser()
parser.add_argument('--model',
help='.tflite model path',
default=os.path.join(default_model_dir, default_model))
parser.add_argument('--labels',
help='label file path',
default=os.path.join(default_model_dir,
default_labels))
parser.add_argument(
'--top_k',
type=int,
default=3,
help='number of categories with highest score to display')
parser.add_argument('--camera_idx',
type=int,
help='Index of which video source to use. ',
default=0)
parser.add_argument('--threshold',
type=float,
default=0.1,
help='classifier score threshold')
args = parser.parse_args()
print('Loading {} with {} labels.'.format(args.model, args.labels))
interpreter = make_interpreter(args.model)
interpreter.allocate_tensors()
labels = read_label_file(args.labels)
inference_size = input_size(interpreter)
cap = cv2.VideoCapture(args.camera_idx)
while cap.isOpened():
ret, frame = cap.read()
if not ret:
break
cv2_im = frame
cv2_im_rgb = cv2.cvtColor(cv2_im, cv2.COLOR_BGR2RGB)
cv2_im_rgb = cv2.resize(cv2_im_rgb, inference_size)
run_inference(interpreter, cv2_im_rgb.tobytes())
objs = get_objects(interpreter, args.threshold)[:args.top_k]
cv2_im = append_objs_to_img(cv2_im, inference_size, objs, labels)
cv2.imshow('frame', cv2_im)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-m', '--model', required=True,
help='File path of .tflite file.')
parser.add_argument('-i', '--input',
help='Image to be classified.')
parser.add_argument('-l', '--labels',
help='File path of labels file.')
parser.add_argument('-k', '--top_k', type=int, default=1,
help='Max number of classification results')
parser.add_argument('-t', '--threshold', type=float, default=0.0,
help='Classification score threshold')
parser.add_argument('-c', '--count', type=int, default=5,
help='Number of times to run inference')
args = parser.parse_args()
labels = read_label_file(args.labels) if args.labels else {}
interpreter = make_interpreter(*args.model.split('@'))
interpreter.allocate_tensors()
_, height, width = interpreter.get_input_details()[0]['shape']
size = [height, width]
trigger = GPIO("/dev/gpiochip2", 13, "out") # pin 37
print('----INFERENCE TIME----')
print('Note: The first inference on Edge TPU is slow because it includes',
'loading the model into Edge TPU memory.')
#for i in range(1,351):
while 1:
#input_image_name = "./testSample/img_"+ str(i) + ".jpg"
#input_image_name = "./testSample/img_1.jpg"
#image = Image.open(input_image_name).resize(size, Image.ANTIALIAS)
arr = numpy.random.randint(0,255,(28,28), dtype='uint8')
image = Image.fromarray(arr, 'L').resize(size, Image.ANTIALIAS)
common.set_input(interpreter, image)
start = time.perf_counter()
trigger.write(True)
interpreter.invoke()
trigger.write(False)
inference_time = time.perf_counter() - start
print('%.6fms' % (inference_time * 1000))
classes = classify.get_classes(interpreter, args.top_k, args.threshold)
print('RESULTS for image ', 1)
for c in classes:
print('%s: %.6f' % (labels.get(c.id, c.id), c.score))
def configure(self, modelDir):
# Workaround, if no edgetpu is available
if not edgetpu.list_edge_tpus():
print("No EdgeTPUs found. Using the CPU only...")
from tflite_runtime.interpreter import Interpreter
self.interpreter = Interpreter(modelDir + "/model.tflite")
else:
print("EdgeTPU found. Connecting to it via PyCoral...")
from pycoral.utils.edgetpu import make_interpreter
self.interpreter = make_interpreter(modelDir + "/model.tflite")
self.interpreter.allocate_tensors()
self.modelDir = modelDir
self._inputSize = common.input_size(self.interpreter)
self._labels = dataset.read_label_file(modelDir + "/labels.txt")
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--labels',
'-l',
type=str,
default=None,
help='Labels file')
parser.add_argument('--capture_dir',
'-d',
type=str,
default='capture',
help='Capture directory')
parser.add_argument('--capture_device_index',
'-i',
type=int,
default=0,
help='Capture device index')
args = parser.parse_args()
print("Press buttons '0' .. '9' to save images from the camera.")
labels = {}
if args.labels:
labels = read_label_file(args.labels)
for key in sorted(labels):
print(key, '-', labels[key])
with nonblocking(sys.stdin) as get_char, worker(save_frame) as submit:
# Handle key events from GUI window.
def handle_key(key, frame):
if key == ord('q') or key == ord('Q'):
return False # Stop processing frames.
if ord('0') <= key <= ord('9'):
label_id = key - ord('0')
class_dir = labels.get(label_id, str(label_id))
name = str(round(time.time() * 1000)) + '.png'
filename = os.path.join(args.capture_dir, class_dir, name)
submit((filename, frame.copy()))
return True # Keep processing frames.
for frame in vision.get_frames(
handle_key=handle_key,
capture_device_index=args.capture_device_index):
# Handle key events from console.
ch = get_char()
if ch is not None and not handle_key(ord(ch), frame):
break
def main():
# 入力変数（配列）設定 ->
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-m', '--model', default='mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite',
help='File path of .tflite file.')
parser.add_argument('-i', '--input', default='parrot.jpg',
help='Image to be classified.')
parser.add_argument('-l', '--labels', default='inat_bird_labels.txt',
help='File path of labels file.')
parser.add_argument('-k', '--top_k', type=int, default=1,
help='Max number of classification results')
parser.add_argument('-t', '--threshold', type=float, default=0.0,
help='Classification score threshold')
parser.add_argument('-c', '--count', type=int, default=5,
help='Number of times to run inference')
args = parser.parse_args()
# 入力変数（配列）設定 <-
# ラベル読み込み
labels = read_label_file(args.labels) if args.labels else {}
# モデル読み込み。Coral使用、未使用でモデル異なる
interpreter = make_interpreter(*args.model.split('@'))
# 推論用メモリ確保。モデル読み込み直後に実行必須
interpreter.allocate_tensors()
size = common.input_size(interpreter)
# 入力ファイルをRGB変換しinterpreterサイズに変更
image = Image.open(args.input).convert('RGB').resize(size, Image.ANTIALIAS)
# interpreterに入力イメージをセット
common.set_input(interpreter, image)
print('----INFERENCE TIME----')
print('Note: The first inference on Edge TPU is slow because it includes',
'loading the model into Edge TPU memory.')
# 入力変数（配列）で指定した回数分推論を繰り返す
for _ in range(args.count):
start = time.perf_counter() # 推論時間測定開始
interpreter.invoke() # 推論
inference_time = time.perf_counter() - start # 推論時間測定終了
# 入力変数（配列）で指定した一致率（args.threshold）以上のラベルの上位args.top_kを取得する
classes = classify.get_classes(interpreter, args.top_k, args.threshold)
print('%.1fms' % (inference_time * 1000)) # 推論時間表示
print('-------RESULTS--------')
for c in classes:
print('%s: %.5f' % (labels.get(c.id, c.id), c.score))
def capture_v(args):
global outputFrame, lock
print('Loading {} with {} labels.'.format(args.model, args.labels))
interpreter = make_interpreter(args.model)
interpreter.allocate_tensors()
labels = read_label_file(args.labels)
inference_size = input_size(interpreter)
cap = cv2.VideoCapture(args.camera_idx)
# cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*'MJPG'))
# Sony PS3 EYE cam settings:
# 320x240 @ 125 FPS, 640x480 @ 60 FPS, 320x240 @187 FPS --> use excat FSP setting
cap.set(cv2.CAP_PROP_FPS, 187)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 320),
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 240)
size = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
print("image size=", size)
fps = 0
start_time = time.time()
while cap.isOpened():
ret, frame = cap.read()
if not ret:
break
cv2_im = frame
# cv2_im_rgb = cv2.cvtColor(cv2_im, cv2.COLOR_BGR2RGB)
# cv2_im_rgb = cv2.resize(cv2_im_rgb, inference_size)
# run_inference(interpreter, cv2_im_rgb.tobytes())
# objs = get_objects(interpreter, args.threshold)[:args.top_k]
# cv2_im = append_objs_to_img(cv2_im, inference_size, objs, labels)
with lock:
outputFrame = cv2_im
fps += 1
if fps == 200:
end_time = time.time()
print("cam FPS:", fps / (end_time - start_time))
start_time = time.time()
fps = 0
cap.release()
def classification_task(num_inferences):
tid = threading.get_ident()
print('Thread: %d, %d inferences for classification task' %
(tid, num_inferences))
labels = read_label_file(test_utils.test_data_path('imagenet_labels.txt'))
model_name = 'mobilenet_v1_1.0_224_quant_edgetpu.tflite'
interpreter = make_interpreter(
test_utils.test_data_path(model_name), device=':0')
interpreter.allocate_tensors()
size = common.input_size(interpreter)
print('Thread: %d, using device 0' % tid)
with test_utils.test_image('cat.bmp') as img:
for _ in range(num_inferences):
common.set_input(interpreter, img.resize(size, Image.NEAREST))
interpreter.invoke()
ret = classify.get_classes(interpreter, top_k=1)
self.assertEqual(len(ret), 1)
self.assertEqual(labels[ret[0].id], 'Egyptian cat')
print('Thread: %d, done classification task' % tid)
def init(args):
global HOLDER
HOLDER['model'] = args.model
labels_file = args.models_directory + args.labels
labels = read_label_file(labels_file) if args.labels else {}
model_file = args.models_directory + args.model
interpreter = make_interpreter(model_file)
interpreter.allocate_tensors()
print("\n Loaded engine with model : {}".format(model_file))
# Model must be uint8 quantized
if common.input_details(interpreter, 'dtype') != np.uint8:
raise ValueError('Only support uint8 input type.')
size = common.input_size(interpreter)
HOLDER['labels'] = labels
HOLDER['interpreter'] = interpreter
HOLDER['size'] = size
HOLDER['top_k'] = args.top_k
def run(self):
print('Loading {} with {} labels.'.format(self.model, self.labels))
interpreter = make_interpreter(self.model)
interpreter.allocate_tensors()
readLabels = read_label_file(self.labels)
inference_size = input_size(interpreter)
while(True):
# Capture frame-by-frame
frameWebcam = self.webcam.read()
frameWebcam = imutils.resize(frameWebcam, width=800)
framePicam = self.picam.read()
framePicam = imutils.resize(framePicam, width=600)
# Wenn nicht Coral eingesetzt werden soll, dann die Zeile auskommentieren und den nächsten Block kommentieren
#grayWebcam = cv2.cvtColor(frameWebcam, cv2.COLOR_BGR2GRAY)
#Bild holen und dieses danach im Coral Interpreter verarbeiten
cv2_im_rgb = cv2.cvtColor(frameWebcam, cv2.COLOR_BGR2RGB)
cv2_im_rgb = cv2.resize(cv2_im_rgb, inference_size)
run_inference(interpreter, cv2_im_rgb.tobytes())
objs = get_objects(interpreter, self.threshold)[:self.top_k]
cv2_im = self.append_objs_to_img(
frameWebcam, inference_size, objs, readLabels)
#Video in Datei schreiben
self.out.write(cv2_im)
#starten der Picam
grayPicam = cv2.cvtColor(framePicam, cv2.COLOR_BGR2GRAY)
grayPicam = cv2.rotate(grayPicam, cv2.cv2.ROTATE_180)
#grayPicam = cv2.GaussianBlur(grayPicam, (21, 21), 0)
# Display the resulting frame
cv2.imshow("RobotBack", grayPicam)
cv2.imshow("RobotFront", cv2_im)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything done, release the capture
self.out.release()
cv2.destroyAllWindows()
self.webcam.stop()
self.picam.stop()
def main():
labels = read_label_file("models/coco_labels.txt")
interpreter = make_interpreter(
"models/ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite")
interpreter.allocate_tensors()
threshold = 0.4
printInfo("ready")
while True:
line = sys.stdin.readline().rstrip("\n")
try:
#load image from shinobi stream
rawImage = BytesIO(base64.b64decode(line))
image = Image.open(rawImage)
#resize the image for object detection using built in coral code
#it will set it to 300x300 and provide a scale for object detection later
_, scale = common.set_resized_input(
interpreter, image.size,
lambda size: image.resize(size, Image.ANTIALIAS))
start = time.perf_counter()
interpreter.invoke()
inference_time = time.perf_counter() - start
#passing the scale from above, this function creates the bounding boxes
#it takes the 300x300 image and divides the scale ratio for original coordinates
objs = detect.get_objects(interpreter, threshold, scale)
output = []
for obj in objs:
label = labels.get(obj.id, obj.id)
labelID = obj.id
score = obj.score
bbox = obj.bbox
output.append({"bbox": bbox, "class": label, "score": score})
#outputted data is based on original feed in image size
printData(output, (inference_time * 1000))
except Exception as e:
printError(str(e))
def main():
global mot_tracker
default_model_dir = '../models'
default_model = 'mobilenet_ssd_v2_coco_quant_postprocess_edgetpu.tflite'
default_labels = 'coco_labels.txt'
parser = argparse.ArgumentParser()
parser.add_argument('--model', help='.tflite model path',
default=os.path.join(default_model_dir,default_model))
parser.add_argument('--labels', help='label file path',
default=os.path.join(default_model_dir, default_labels))
parser.add_argument('--top_k', type=int, default=3,
help='number of categories with highest score to display')
parser.add_argument('--camera_idx', type=int, help='Index of which video source to use. ', default = 0)
parser.add_argument('--threshold', type=float, default=0.1,
help='classifier score threshold')
parser.add_argument('--tracker', help='Name of the Object Tracker To be used.',
default=None,
choices=[None, 'sort'])
parser.add_argument('--videosrc', help='Directly connected (dev) or Networked (net) video source. ', choices=['dev','net','file'],
default='dev')
parser.add_argument('--display', help='Is a display attached',
default='False',
choices=['True', 'False'])
parser.add_argument('--netsrc', help="Networked video source, example format: rtsp://192.168.1.43/mpeg4/media.amp",)
parser.add_argument('--filesrc', help="Video file source. The videos subdirectory gets mapped into the Docker container, so place your files there.",)
parser.add_argument('--modelInt8', help="Model expects input tensors to be Int8, not UInt8", default='False', choices=['True', 'False'])
args = parser.parse_args()
trackerName=args.tracker
''' Check for the object tracker.'''
if trackerName != None:
if trackerName == 'mediapipe':
if detectCoralDevBoard():
objectOfTracker = ObjectTracker('mediapipe')
else:
print("Tracker MediaPipe is only available on the Dev Board. Keeping the tracker as None")
trackerName = None
else:
objectOfTracker = ObjectTracker(trackerName)
else:
pass
if trackerName != None and objectOfTracker:
mot_tracker = objectOfTracker.trackerObject.mot_tracker
else:
mot_tracker = None
print('Loading {} with {} labels.'.format(args.model, args.labels))
interpreter = make_interpreter(args.model)
interpreter.allocate_tensors()
labels = read_label_file(args.labels)
inference_size = input_size(interpreter)
if args.modelInt8=='True':
model_int8 = True
else:
model_int8 = False
if args.videosrc=='dev':
cap = cv2.VideoCapture(args.camera_idx)
elif args.videosrc=='file':
cap = cv2.VideoCapture(args.filesrc)
else:
if args.netsrc==None:
print("--videosrc was set to net but --netsrc was not specified")
sys.exit()
cap = cv2.VideoCapture(args.netsrc)
cap.set(cv2.CAP_PROP_BUFFERSIZE, 0)
while cap.isOpened():
ret, frame = cap.read()
if not ret:
if args.videosrc=='file':
cap = cv2.VideoCapture(args.filesrc)
continue
else:
break
cv2_im = frame
cv2_im_rgb = cv2.cvtColor(cv2_im, cv2.COLOR_BGR2RGB)
cv2_im_rgb = cv2.resize(cv2_im_rgb, inference_size)
if model_int8:
im_pil = Image.fromarray(cv2_im_rgb)
input_type = common.input_details(interpreter, 'dtype')
img = (input_type(cv2_im_rgb)- 127.5) / 128.0
run_inference(interpreter, img.flatten())
else:
run_inference(interpreter, cv2_im_rgb.tobytes())
objs = get_objects(interpreter, args.threshold)[:args.top_k]
height, width, channels = cv2_im.shape
scale_x, scale_y = width / inference_size[0], height / inference_size[1]
detections = [] # np.array([])
for obj in objs:
bbox = obj.bbox.scale(scale_x, scale_y)
element = [] # np.array([])
element.append(bbox.xmin)
element.append(bbox.ymin)
element.append(bbox.xmax)
element.append(bbox.ymax)
element.append(obj.score) # print('element= ',element)
element.append(obj.id)
detections.append(element) # print('dets: ',dets)
# convert to numpy array # print('npdets: ',dets)
detections = np.array(detections)
trdata = []
trackerFlag = False
if detections.any():
if mot_tracker != None:
trdata = mot_tracker.update(detections)
trackerFlag = True
cv2_im = append_objs_to_img(cv2_im, detections, labels, trdata, trackerFlag)
if args.display == 'True':
cv2.imshow('frame', cv2_im)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model",
help="File path of Tflite model.",
required=True)
parser.add_argument("--label",
help="File path of label file.",
required=True)
parser.add_argument("--threshold",
help="threshold to filter results.",
default=0.5,
type=float)
parser.add_argument("--width",
help="Resolution width.",
default=640,
type=int)
parser.add_argument("--height",
help="Resolution height.",
default=480,
type=int)
parser.add_argument("--videopath",
help="File path of Videofile.",
default="")
args = parser.parse_args()
# Initialize window.
cv2.namedWindow(
WINDOW_NAME,
cv2.WINDOW_GUI_NORMAL | cv2.WINDOW_AUTOSIZE | cv2.WINDOW_KEEPRATIO)
cv2.moveWindow(WINDOW_NAME, 100, 200)
# Initialize engine and load labels.
interpreter = make_interpreter(args.model)
interpreter.allocate_tensors()
labels = read_label_file(args.label) if args.label else None
# Generate random colors.
last_key = sorted(labels.keys())[len(labels.keys()) - 1]
colors = visual.random_colors(last_key)
# Video capture.
if args.videopath == "":
print("Open camera.")
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, args.width)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, args.height)
else:
print("Open video file: ", args.videopath)
cap = cv2.VideoCapture(args.videopath)
cap_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
cap_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
elapsed_list = []
while cap.isOpened():
_, frame = cap.read()
im = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# Run inference.
start = time.perf_counter()
_, scale = common.set_resized_input(interpreter,
(cap_width, cap_height),
lambda size: cv2.resize(im, size))
interpreter.invoke()
elapsed_ms = (time.perf_counter() - start) * 1000
# Display result.
objects = detect.get_objects(interpreter, args.threshold, scale)
if objects:
for obj in objects:
label_name = "Unknown"
if labels:
labels.get(obj.id, "Unknown")
label_name = labels[obj.id]
caption = "{0}({1:.2f})".format(label_name, obj.score)
# Draw a rectangle and caption.
box = (obj.bbox.xmin, obj.bbox.ymin, obj.bbox.xmax,
obj.bbox.ymax)
visual.draw_rectangle(frame, box, colors[obj.id])
visual.draw_caption(frame, box, caption)
# Calc fps.
elapsed_list.append(elapsed_ms)
avg_text = ""
if len(elapsed_list) > 100:
elapsed_list.pop(0)
avg_elapsed_ms = np.mean(elapsed_list)
avg_text = " AGV: {0:.2f}ms".format(avg_elapsed_ms)
# Display fps
fps_text = "{0:.2f}ms".format(elapsed_ms)
visual.draw_caption(frame, (10, 30), fps_text + avg_text)
# display
cv2.imshow(WINDOW_NAME, frame)
if cv2.waitKey(10) & 0xFF == ord("q"):
break
# When everything done, release the window
cv2.destroyAllWindows()
def run_classifier_example():
labels = read_label_file(vision.CLASSIFICATION_LABELS)
classifier = vision.Classifier(vision.CLASSIFICATION_MODEL)
for frame in vision.get_frames('Object Classifier', size=(640, 480)):
classes = classifier.get_classes(frame)
vision.draw_classes(frame, classes, labels)
def run_object_detector_example():
detector = vision.Detector(vision.OBJECT_DETECTION_MODEL)
labels = read_label_file(vision.OBJECT_DETECTION_LABELS)
for frame in vision.get_frames('Object Detector', size=(640, 480)):
objects = detector.get_objects(frame, threshold=0.2)
vision.draw_objects(frame, objects, labels)
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument(
'-m',
'--models',
required=True,
help=('File path template of .tflite model segments, e.g.,'
'inception_v3_299_quant_segment_%d_of_2_edgetpu.tflite'))
parser.add_argument('-i',
'--input',
required=True,
help='Image to be classified.')
parser.add_argument('-l', '--labels', help='File path of labels file.')
parser.add_argument('-k',
'--top_k',
type=int,
default=1,
help='Max number of classification results')
parser.add_argument('-t',
'--threshold',
type=float,
default=0.0,
help='Classification score threshold')
parser.add_argument('-c',
'--count',
type=int,
default=5,
help='Number of times to run inference')
args = parser.parse_args()
labels = read_label_file(args.labels) if args.labels else {}
result = re.search(r'^.*_segment_%d_of_(?P<num_segments>[0-9]+)_.*.tflite',
args.models)
if not result:
raise ValueError(
'--models should follow *_segment%d_of_[num_segments]_*.tflite pattern'
)
num_segments = int(result.group('num_segments'))
model_paths = [args.models % i for i in range(num_segments)]
devices = _get_devices(num_segments)
runner = _make_runner(model_paths, devices)
size = common.input_size(runner.interpreters()[0])
image = np.array(
Image.open(args.input).convert('RGB').resize(size, Image.ANTIALIAS))
def producer():
for _ in range(args.count):
runner.push([image])
runner.push([])
def consumer():
output_details = runner.interpreters()[-1].get_output_details()[0]
scale, zero_point = output_details['quantization']
while True:
result = runner.pop()
if not result:
break
scores = scale * (result[0][0].astype(np.int64) - zero_point)
classes = classify.get_classes_from_scores(scores, args.top_k,
args.threshold)
print('-------RESULTS--------')
for klass in classes:
print('%s: %.5f' % (labels.get(klass.id, klass.id), klass.score))
start = time.perf_counter()
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)
producer_thread.start()
consumer_thread.start()
producer_thread.join()
consumer_thread.join()
average_time_ms = (time.perf_counter() - start) / args.count * 1000
print('Average inference time (over %d iterations): %.1fms' %
(args.count, average_time_ms))
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-m',
'--model',
required=True,
help='File path of .tflite file')
parser.add_argument('-i',
'--input',
required=True,
help='File path of image to process')
parser.add_argument('-l', '--labels', help='File path of labels file')
parser.add_argument('-t',
'--threshold',
type=float,
default=0.4,
help='Score threshold for detected objects')
parser.add_argument('-o',
'--output',
help='File path for the result image with annotations')
parser.add_argument('-c',
'--count',
type=int,
default=5,
help='Number of times to run inference')
args = parser.parse_args()
labels = read_label_file(args.labels) if args.labels else {}
interpreter = make_interpreter(args.model)
interpreter.allocate_tensors()
image = Image.open(args.input)
_, scale = common.set_resized_input(
interpreter, image.size,
lambda size: image.resize(size, Image.ANTIALIAS))
print('----INFERENCE TIME----')
print('Note: The first inference is slow because it includes',
'loading the model into Edge TPU memory.')
for _ in range(args.count):
start = time.perf_counter()
interpreter.invoke()
inference_time = time.perf_counter() - start
objs = detect.get_objects(interpreter, args.threshold, scale)
print('%.2f ms' % (inference_time * 1000))
print('-------RESULTS--------')
if not objs:
print('No objects detected')
for obj in objs:
print(labels.get(obj.id, obj.id))
print(' id: ', obj.id)
print(' score: ', obj.score)
print(' bbox: ', obj.bbox)
if args.output:
image = image.convert('RGB')
draw_objects(ImageDraw.Draw(image), objs, labels)
image.save(args.output)
image.show()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model",
help="File path of Tflite model.",
required=True)
parser.add_argument("--label",
help="File path of label file.",
required=True)
parser.add_argument("--threshold",
help="threshold to filter results.",
type=float,
default=0.5)
parser.add_argument("--width", help="Resolution width.", default=640)
parser.add_argument("--height", help="Resolution height.", default=480)
args = parser.parse_args()
# Initialize window.
cv2.namedWindow(
WINDOW_NAME,
cv2.WINDOW_GUI_NORMAL | cv2.WINDOW_AUTOSIZE | cv2.WINDOW_KEEPRATIO)
cv2.moveWindow(WINDOW_NAME, 100, 200)
# Initialize engine and load labels.
interpreter = make_interpreter(args.model)
interpreter.allocate_tensors()
labels = read_label_file(args.label) if args.label else None
# Generate random colors.
last_key = sorted(labels.keys())[len(labels.keys()) - 1]
colors = visual.random_colors(last_key)
is_inpaint_mode = False
resolution_width = args.width
rezolution_height = args.height
with picamera.PiCamera() as camera:
camera.resolution = (resolution_width, rezolution_height)
camera.framerate = 30
rawCapture = PiRGBArray(camera)
# allow the camera to warmup
time.sleep(0.1)
try:
for frame in camera.capture_continuous(rawCapture,
format="rgb",
use_video_port=True):
start_ms = time.time()
rawCapture.truncate(0)
image = frame.array
im = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
# Run inference.
start = time.perf_counter()
_, scale = common.set_resized_input(
interpreter,
(resolution_width, rezolution_height),
lambda size: cv2.resize(image, size),
)
interpreter.invoke()
# Display result.
objects = detect.get_objects(interpreter, args.threshold,
scale)
if is_inpaint_mode == True:
mask = np.full((args.height, args.width),
0,
dtype=np.uint8)
for obj in objects:
if labels and obj.id in labels:
# Draw a mask rectangle.
box = (
obj.bbox.xmin,
obj.bbox.ymin,
obj.bbox.xmax,
obj.bbox.ymax,
)
visual.draw_rectangle(mask,
box, (255, 255, 255),
thickness=-1)
# Image Inpainting
dst = cv2.inpaint(im, mask, 3, cv2.INPAINT_TELEA)
# dst = cv2.inpaint(im, mask,3,cv2.INPAINT_NS)
else:
for obj in objects:
if labels and obj.id in labels:
label_name = labels[obj.id]
caption = "{0}({1:.2f})".format(
label_name, obj.score)
# Draw a rectangle and caption.
box = (
obj.bbox.xmin,
obj.bbox.ymin,
obj.bbox.xmax,
obj.bbox.ymax,
)
visual.draw_rectangle(im, box, colors[obj.id])
visual.draw_caption(im, box, caption)
dst = im
# Calc fps.
elapsed_ms = time.time() - start_ms
fps = 1 / elapsed_ms
# Display fps
fps_text = "{0:.2f}ms, {1:.2f}fps".format(
(elapsed_ms * 1000.0), fps)
visual.draw_caption(dst, (10, 30), fps_text)
# Display image
cv2.imshow(WINDOW_NAME, dst)
key = cv2.waitKey(10) & 0xFF
if key == ord("q"):
break
elif key == ord(" "):
is_inpaint_mode = not is_inpaint_mode
print("inpant mode change :", is_inpaint_mode)
finally:
camera.stop_preview()
# When everything done, release the window
cv2.destroyAllWindows()
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-m', '--model', required=True,
help='Model directory')
args = parser.parse_args()
# Load tflite model
detector = edgetpu.make_interpreter(os.path.join(args.model, "detector.tflite"))
detector.allocate_tensors()
labels = dataset.read_label_file(os.path.join(args.model, 'labels.txt'))
# Load webcam
prevTime = 0
cap = cv.VideoCapture(0)
rows, cols = 320, 320
cap.set(cv.CAP_PROP_FRAME_WIDTH, 320)
cap.set(cv.CAP_PROP_FRAME_HEIGHT, 320)
# Run model
while(True):
_, image = cap.read()
# 이미지의 중심점을 기준으로 90도 회전 하면서 0.5배 Scale
image = cv.cvtColor(image, cv.COLOR_BGR2RGB)
M= cv.getRotationMatrix2D((cols/2, rows/2),180, 1)
image = cv.warpAffine(image, M, (cols, rows))
image = Image.fromarray(image, "RGB")
_, scale = common.set_resized_input(detector, image.size, lambda size: image.resize(size, Image.ANTIALIAS))
# Insert FPS
curTime = time.time()
detector.invoke()
objs = detect.get_objects(detector, 0.6, scale)
draw_image = image.copy()
if not objs:
draw_no_detect(draw_image)
else:
draw_objects(draw_image, objs, labels)
sec = curTime - prevTime
prevTime = curTime
fps = 1/(sec)
str = "FPS : %0.1f" % fps
draw_text(draw_image, str, (0, 0))
draw_image = np.array(draw_image)
draw_image = cv.cvtColor(draw_image, cv.COLOR_RGB2BGR)
# Display frame
cv.imshow("Frame", draw_image)
key = cv.waitKey(1) & 0xff
if key==27:
# Stop using ESC
break
rr = (145, 0, 0)
gg = (0, 128, 0)
idle = [
k, k, r, g, gg, g, k, k, k, r, g, k, g, g, g, g, k, k, w, w, g, g, g, g, k,
r, w, w, g, g, g, g, k, k, r, f, w, w, w, k, gg, r, gg, gg, f, f, gg, k, k,
gg, g, gg, f, f, gg, gg, k, k, r, r, k, rr, rr, k
]
sense.set_pixels(idle)
# Main program ------------------------
# Load the neural network model
detector = vision.Detector(vision.OBJECT_DETECTION_MODEL)
labels_d = read_label_file(vision.OBJECT_DETECTION_LABELS)
classifier = vision.Classifier(vision.CLASSIFICATION_MODEL)
labels = read_label_file(
vision.CLASSIFICATION_LABELS) #renders labels for objects detected
# Run a loop to get images and process them in real-time
for frame in vision.get_frames():
classes = classifier.get_classes(frame)
# Get list of all recognized objects in the frame
label_id = classes[0].id
score = classes[0].score
label = labels.get(label_id)
#label = labels[classes[0].id] optimized version remove label_id variable
#label = labels[label_id] #could also use this code for label
print(label_id, label, score)
# Draw the label name on the video
args = parser.parse_args()
app = Flask(__name__)
socketio = SocketIO(app)
face_cascade = cv2.CascadeClassifier(args.haar)
def detectface(img):
image = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2GRAY)
faces = face_cascade.detectMultiScale(image, 1.1, 4)
x, y, w, h = faces[0]
image = img[y:y + h, x:x + w]
return image
labels = read_label_file(args.labels)
interpreter = make_interpreter(args.model)
interpreter.allocate_tensors()
size = common.input_size(interpreter)
@app.route('/')
def homeroute():
return render_template('index.html')
@socketio.on('imgdata')
def getimagedata(message):
message = bytes(message, encoding='utf-8')
message = message[message.find(b'/9'):]
pimage = Image.open(io.BytesIO(base64.b64decode(message)))
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model", help="File path of Tflite model.", required=True)
parser.add_argument("--label", help="File path of label file.", required=True)
parser.add_argument(
"--threshold", help="threshold to filter results.", default=0.5, type=float
)
parser.add_argument("--width", help="Resolution width.", default=640, type=int)
parser.add_argument("--height", help="Resolution height.", default=480, type=int)
args = parser.parse_args()
# Initialize window.
cv2.namedWindow(
WINDOW_NAME, cv2.WINDOW_GUI_NORMAL | cv2.WINDOW_AUTOSIZE | cv2.WINDOW_KEEPRATIO
)
cv2.moveWindow(WINDOW_NAME, 100, 200)
# Initialize engine and load labels.
interpreter = make_interpreter(args.model)
interpreter.allocate_tensors()
labels = read_label_file(args.label) if args.label else None
# Generate random colors.
last_key = sorted(labels.keys())[len(labels.keys()) - 1]
colors = visual.random_colors(last_key)
elapsed_list = []
resolution_width = args.width
rezolution_height = args.height
with picamera.PiCamera() as camera:
camera.resolution = (resolution_width, rezolution_height)
camera.framerate = 30
_, width, height, channels = engine.get_input_tensor_shape()
rawCapture = PiRGBArray(camera)
# allow the camera to warmup
time.sleep(0.1)
try:
for frame in camera.capture_continuous(
rawCapture, format="rgb", use_video_port=True
):
rawCapture.truncate(0)
image = frame.array
im = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
# Run inference.
start = time.perf_counter()
_, scale = common.set_resized_input(
interpreter, (resolution_width, rezolution_height), lambda size: cv2.resize(image, size)
)
interpreter.invoke()
elapsed_ms = engine.get_inference_time()
# Display result.
objects = detect.get_objects(interpreter, args.threshold, scale)
if objects:
for obj in objects:
label_name = "Unknown"
if labels:
labels.get(obj.id, "Unknown")
label_name = labels[obj.id]
caption = "{0}({1:.2f})".format(label_name, obj.score)
# Draw a rectangle and caption.
box = (obj.bbox.xmin, obj.bbox.ymin, obj.bbox.xmax, obj.bbox.ymax)
visual.draw_rectangle(im, box, colors[obj.id])
visual.draw_caption(im, box, caption)
# Calc fps.
elapsed_list.append(elapsed_ms)
avg_text = ""
if len(elapsed_list) > 100:
elapsed_list.pop(0)
avg_elapsed_ms = np.mean(elapsed_list)
avg_text = " AGV: {0:.2f}ms".format(avg_elapsed_ms)
# Display fps
fps_text = "{0:.2f}ms".format(elapsed_ms)
visual.draw_caption(im, (10, 30), fps_text + avg_text)
# display
cv2.imshow(WINDOW_NAME, im)
if cv2.waitKey(10) & 0xFF == ord("q"):
break
finally:
camera.stop_preview()
# When everything done, release the window
cv2.destroyAllWindows()
default=DEFAULT_MODELS_DIRECTORY,
help="the directory containing the model & labels files",
)
parser.add_argument(
"--model",
default=DEFAULT_MODEL,
help="model file",
)
parser.add_argument("--labels",
default=DEFAULT_LABELS,
help="labels file of model")
parser.add_argument("--port", default=5000, type=int, help="port number")
args = parser.parse_args()
global MODEL
MODEL = args.model
model_file = os.path.join(args.models_directory, args.model)
assert os.path.isfile(model_file)
labels_file = os.path.join(args.models_directory, args.labels)
assert os.path.isfile(labels_file)
global labels
labels = dataset.read_label_file(labels_file)
global interpreter
interpreter = edgetpu.make_interpreter(model_file)
interpreter.allocate_tensors()
print("\n Initialised interpreter with model : {}".format(model_file))
app.run(host="0.0.0.0", debug=True, port=args.port)
def main():
default_model_dir = '../all_models'
default_model = 'mobilenet_v2_1.0_224_quant_edgetpu.tflite'
default_labels = 'imagenet_labels.txt'
parser = argparse.ArgumentParser()
parser.add_argument('--model',
help='.tflite model path',
default=os.path.join(default_model_dir, default_model))
parser.add_argument('--labels',
help='label file path',
default=os.path.join(default_model_dir,
default_labels))
parser.add_argument(
'--top_k',
type=int,
default=3,
help='number of categories with highest score to display')
parser.add_argument('--threshold',
type=float,
default=0.1,
help='classifier score threshold')
parser.add_argument('--videosrc',
help='Which video source to use. ',
default='/dev/video0')
parser.add_argument('--headless',
help='Run without displaying the video.',
default=False,
type=bool)
parser.add_argument('--videofmt',
help='Input video format.',
default='raw',
choices=['raw', 'h264', 'jpeg'])
args = parser.parse_args()
print('Loading {} with {} labels.'.format(args.model, args.labels))
interpreter = make_interpreter(args.model)
interpreter.allocate_tensors()
labels = read_label_file(args.labels)
inference_size = input_size(interpreter)
# Average fps over last 30 frames.
fps_counter = avg_fps_counter(30)
def user_callback(input_tensor, src_size, inference_box):
nonlocal fps_counter
start_time = time.monotonic()
run_inference(interpreter, input_tensor)
results = get_classes(interpreter, args.top_k, args.threshold)
end_time = time.monotonic()
text_lines = [
' ',
'Inference: {:.2f} ms'.format((end_time - start_time) * 1000),
'FPS: {} fps'.format(round(next(fps_counter))),
]
for result in results:
text_lines.append('score={:.2f}: {}'.format(
result.score, labels.get(result.id, result.id)))
print(' '.join(text_lines))
return generate_svg(src_size, text_lines)
result = gstreamer.run_pipeline(user_callback,
src_size=(640, 480),
appsink_size=inference_size,
videosrc=args.videosrc,
videofmt=args.videofmt,
headless=args.headless)
