def main(img_path): # path_file = FLAGS.path_file # # for count, foldername in enumerate(os.listdir(path_file)): # print(count, foldername) # for count, filename in enumerate(os.listdir(path_file + '/' + foldername)): # print(count, filename) # dst_name = filename.split('/')[-1].split('.jpg')[0] + '_crop' + '.jpg' # path_src_file = path_file + '/' + foldername + '/' + filename # path_dst_file = path_file + '/' + foldername + '/' + dst_name # print(path_src_file) config = ConfigProto() #config.gpu_options.per_process_gpu_memory_fraction = 0.4 #session = InteractiveSession(config=config) config.gpu_options.allow_growth = True session = InteractiveSession(config=config) STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS) input_size = 416 image_path = img_path weights = './checkpoints/yolov4-416' print(image_path) original_image = cv2.imread(image_path) original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB) # image_data = utils.image_preprocess(np.copy(original_image), [input_size, input_size]) image_data = cv2.resize(original_image, (input_size, input_size)) image_data = image_data / 255. # image_data = image_data[np.newaxis, ...].astype(np.float32) images_data = [] for i in range(1): images_data.append(image_data) images_data = np.asarray(images_data).astype(np.float32) saved_model_loaded = tf.saved_model.load(weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] batch_data = tf.constant(images_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=FLAGS.iou, score_threshold=FLAGS.score) # print(boxes.numpy()[0][0]) # #print(classes.numpy()[0][0]) # error=0 pred_bbox = [ boxes.numpy(), scores.numpy(), classes.numpy(), valid_detections.numpy() ] #rint(pred_bbox) image = utils.draw_bbox_and_crop(original_image, pred_bbox, size=224) #image = utils.draw_bbox(image_data*255, pred_bbox) # if error == 1: # print('dog 검출 x') image = Image.fromarray(image.astype(np.uint8)) image.show() image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB) cv2.imwrite(image_path, image)
# # Depth Estimation from RGB Images import numpy as np from glob import glob from utils import deep_utils from utils.image_utils import depth_read, rgb_read, depth_read_kitti from models import models from tensorflow.keras.callbacks import TensorBoard, ModelCheckpoint from tensorflow.keras.optimizers import Adam import datetime from tensorflow.compat.v1 import ConfigProto from tensorflow.compat.v1 import InteractiveSession import segmentation_models config = ConfigProto() config.gpu_options.per_process_gpu_memory_fraction = 0.9 config.gpu_options.allow_growth = True session = InteractiveSession(config=config) def _batchGenerator(X_filelist, y_filelist, batchSize): """ Yield X and Y data when the batch is filled. """ #Sort filelists to confirm they are same order X_filelist.sort(key=lambda f: int(''.join(filter(str.isdigit, f)))) y_filelist.sort(key=lambda f: int(''.join(filter(str.isdigit, f)))) #Shuffle order of filenames X_filelist, y_filelist = deep_utils.simul_shuffle(X_filelist, y_filelist)
def training(sweep_q, worker_q): # GPU-initialization gpu_config = ConfigProto() gpu_config.gpu_options.per_process_gpu_memory_fraction = 0.3 gpu_config.gpu_options.allow_growth = True session = InteractiveSession(config=gpu_config) reset_wandb_env() worker_data = worker_q.get() run_name = "{}-{}".format(worker_data.sweep_run_name, worker_data.num) config = worker_data.config train = worker_data.train test = worker_data.test num_classes = worker_data.num_classes x = worker_data.x y = worker_data.y run = wandb.init( group=worker_data.sweep_name, job_type=worker_data.sweep_run_name, name=run_name, config=config, ) # Model dropout = run.config.dropout nodesizes = [ run.config.node_size2, run.config.node_size3, run.config.node_size4 ] model = Sequential() model.add( Bidirectional(LSTM(run.config.node_size1, return_sequences=True), input_shape=(x.shape[1], x.shape[2]))) model.add(Dropout(rate=dropout)) for i in range( 0, run.config.num_layers): #number of layers ramdom between 1 an 3 model.add(Bidirectional(LSTM(nodesizes[i], return_sequences=True))) model.add(Dropout(rate=dropout)) model.add(Bidirectional(LSTM(run.config.node_size5))) model.add(Dropout(rate=dropout)) model.add(Dense(num_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer=run.config.optimizer, metrics=['accuracy', Precision(), Recall()]) model.summary() model.fit(x[train], y[train], epochs=run.config.epochs, batch_size=run.config.batch_size, validation_data=(x[test], y[test]), shuffle=False, verbose=2, callbacks=[WandbCallback()]) #Test accuracy model_best_path = os.path.join(run.dir, "model-best.h5") best_model = load_model(filepath=model_best_path) y_eval = best_model.evaluate(x[test], y[test], verbose=0) #Confusion Matrix y_pred = best_model.predict(x[test]) y_pred_integer = np.argmax(y_pred, axis=1) y_test_integer = np.argmax(y[test], axis=1) y_pred_name = ([worker_data.token_labels[p] for p in y_pred_integer]) y_test_name = ([worker_data.token_labels[p] for p in y_test_integer]) wandb.sklearn.plot_confusion_matrix(y_test_name, y_pred_name) #Convert to TFLite tflite_converter = tf.lite.TFLiteConverter.from_keras_model(best_model) tflite_converter.experimental_new_converter = True tflite_model = tflite_converter.convert() open(os.path.join(wandb.run.dir, "model-best.tflite"), "wb").write(tflite_model) #Finish Run run.log(dict(val_accuracy=y_eval[1])) wandb.join() sweep_q.put(WorkerDoneData(val_accuracy=y_eval[1]))
from ensemblenet import StackingModel import tensorflow.keras as keras import numpy as np import tensorflow as tf from tensorflow.compat.v1 import ConfigProto, Session, RunOptions from tensorflow.compat.v1.keras.backend import set_session # Run Options np.random.seed(0) # Seed for reproducing tf.keras.fit_verbose = 2 # Print status after every epoch RunOptions.report_tensor_allocations_upon_oom = True # Out-of-memory display config = ConfigProto() config.gpu_options.allow_growth = True # dynamically grow GPU memory config.log_device_placement = True sess = Session(config=config) set_session(sess) num_classes = 10 # Load data and clean ((x_train, y_train), (x_test, y_test)) = keras.datasets.mnist.load_data() (x_train, x_test) = map(lambda data: data.astype("float32") / 255, (x_train, x_test)) (x_train, x_test) = map(lambda data: np.expand_dims(data, -1), (x_train, x_test)) (y_train, y_test) = map(lambda data: keras.utils.to_categorical(data, num_classes), (y_train, y_test))
from __future__ import absolute_import # __future__: 把下一個新版本的特性匯入到當前版本 from __future__ import division from __future__ import print_function import abc from abc import ABC import six # Python 2 and 3 compatibility library import tensorflow as tf from tensorflow.compat.v1 import ConfigProto from tensorflow.compat.v1 import InteractiveSession import MultiHeadAttention tfconfig = ConfigProto(allow_soft_placement=True) tfconfig.gpu_options.allow_growth = True session = InteractiveSession(config=tfconfig) # Registry layer keys. ATTEND_TO_ENCODER_REGISTRY_KEY = "attend_to_encoder" ATTENTION_32_HEADS_REGISTRY_KEY = "attention_32_heads" ATTENTION_16_HEADS_REGISTRY_KEY = "attention_16_heads" ATTENTION_4_HEADS_REGISTRY_KEY = "attention_4_heads" DEPTHWISE_CONV_3X1_REGISTRY_KEY = "depthwise_conv_3x1" DEPTHWISE_CONV_5X1_REGISTRY_KEY = "depthwise_conv_5x1" DEPTHWISE_CONV_7X1_REGISTRY_KEY = "depthwise_conv_7x1" DILATED_CONV_3X1_REGISTRY_KEY = "dilated_conv_3x1" DILATED_CONV_5X1_REGISTRY_KEY = "dilated_conv_5x1" GATED_LINEAR_UNIT_REGISTRY_KEY = "gated_linear_unit" IDENTITY_REGISTRY_KEY = "identity" # Lightweight convolution naming convention uses "R_X" where X is the variable # reduction factor. LIGHTWEIGHT_CONV_3X1_R_1_REGISTRY_KEY = "lightweight_conv_3x1_r_1" LIGHTWEIGHT_CONV_3X1_R_4_REGISTRY_KEY = "lightweight_conv_3x1_r_4"
def main_images(m_type, m_name, logger, data_path=None, actors=[], write_output=True): from tensorflow.compat.v1 import ConfigProto from tensorflow.compat.v1 import InteractiveSession # this thing fixes something _config = ConfigProto() _config.gpu_options.allow_growth = True session = InteractiveSession(config=_config) # --- with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess: # load best model model = load_model(sess, m_type, m_name, logger) eye_info = HierarchicalDict(path=data_path + '/eye_data.json') previos_segment = '' current_segment = '' for data_element in tqdm(data_generator(data_path=data_path, actors=actors), ascii=True): # for data_element in data_generator(data_path=data_path, actors=actors): keys = data_element.keys image = data_element.item current_segment = keys[:-1] if current_segment != previos_segment: last_ars = [deque(maxlen=25) for _ in range(2)] if not eye_info.check_key(keys): continue rois_coords = eye_info[keys]['roi'] contours = eye_info[keys]['cnt'] aspect_ratios = eye_info[keys]['ars'] eye1 = np.array(contours[0]).reshape((-1, 1, 2)) eye2 = np.array(contours[1]).reshape((-1, 1, 2)) eyes = [eye1, eye2] # create empty mask to draw on result = np.zeros(image.shape, np.uint8) for i, (x1, x2, y1, y2) in enumerate(rois_coords): prev_aspect_ratio = sum(last_ars[i]) / len(last_ars[i]) if len(last_ars[i]) else 0.35 current_aspect_ratio = aspect_ratios[i] if current_aspect_ratio < 0.6 * prev_aspect_ratio: continue last_ars[i].append(current_aspect_ratio) roi = image[y1 : y2, x1 : x2] # get the original eye region # preprocessing for the pupil detection model roi_gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY) shape = roi_gray.shape if roi_gray.shape[0] != 192: roi_gray = rescale(roi_gray) roi_gray = gray_normalizer(roi_gray) roi_gray = change_channel(roi_gray, config["input_channel"]) # --- [p] = model.predict(sess, [roi_gray]) x, y, w = upscale_preds(p, shape) x, y, w = [int(item) for item in (x, y, w)] # draw the circle indicating a pupil if cv2.pointPolygonTest(eyes[i], (x + x1, y + y1), False) != -1: cv2.drawContours(result, [eyes[i]], 0, (255, 255, 255), -1) roi = result[y1 : y2, x1 : x2] cv2.circle(roi, (x, y), 9, (0, 0, 255), -1) result[y1 : y2, x1 : x2] = roi # --- previos_segment = current_segment if write_output: actor, domain, segment, idx = keys path = os.path.dirname(os.path.abspath(f'{data_path}/{actor}/{domain}/{segment}')) path = path + '/' + segment + '/original_renders/eye_regions/' if not os.path.exists(path): os.mkdir(path) cv2.imwrite(f'{path}{idx}.jpg', cv2.cvtColor(result, cv2.COLOR_BGR2RGB)) print("Done.")
def main(_argv): # Definition of the parameters max_cosine_distance = 0.4 nn_budget = None nms_max_overlap = 1.0 # initialize deep sort model_filename = os.getenv( 'HOME' ) + '/st_mini/src/scout_mini_ros/scout_bringup/model_data/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename, batch_size=1) # calculate cosine distance metric metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) # initialize tracker tracker = Tracker(metric) # load configuration for object detector config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS) input_size = FLAGS.size if use_webcam: video_path = FLAGS.video # load tflite model if flag is set if FLAGS.framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=FLAGS.weights) interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() print(input_details) print(output_details) # otherwise load standard tensorflow saved model else: saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] if use_webcam: # begin video capture try: vid = cv2.VideoCapture(int(video_path)) except: vid = cv2.VideoCapture(video_path) # 로봇 모터 제어를 위한 초깃값 설정 x = 0 y = 0 z = 0 th = 0 speed = 0.85 turn = 1 # 로봇의 최대,최소 속도 설정 # <!--선속도--!> max_speed = 1.6 min_speed = 0.7 # <!--각속도--!> max_turn = 1.2 min_turn = 1 # 변수 추가 cx, cy, h = 0, 0, 0 frame_num = 0 key = '' # Depth camera class 불러오기 if not use_webcam: dc = DepthCamera() # 장애물 영역 기본값 받아오기 default = Default_dist() # ROS class init go = scout_pub_basic() rate = rospy.Rate(60) # while video is running while not rospy.is_shutdown(): if use_webcam: return_value, frame = vid.read() else: # depth camera 사용 return_value, depth_frame, frame = dc.get_frame() if return_value: frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) image = Image.fromarray(frame) else: print('Video has ended or failed, try a different video format!') break frame_num += 1 # 좌/우 회전 한곗값 설정 left_limit = frame.shape[1] // 2 - 70 right_limit = frame.shape[1] // 2 + 70 if not use_webcam: # 장애물 회피를 위한 ROI 디폴트 세팅하기 (현재는 10프레임만) 추가 if frame_num < 11: default.default_update(depth_frame) continue print('Frame #: ', frame_num) #frame_size = frame.shape[:2] image_data = cv2.resize(frame, (input_size, input_size)) image_data = image_data / 255. image_data = image_data[np.newaxis, ...].astype(np.float32) start_time = time.time() # run detections on tflite if flag is set if FLAGS.framework == 'tflite': interpreter.set_tensor(input_details[0]['index'], image_data) interpreter.invoke() pred = [ interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details)) ] # run detections using yolov3 if flag is set if FLAGS.model == 'yolov3' and FLAGS.tiny == True: boxes, pred_conf = filter_boxes(pred[1], pred[0], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: batch_data = tf.constant(image_data) pred_bbox = infer(batch_data) for _, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=FLAGS.iou, score_threshold=FLAGS.score) # convert data to numpy arrays and slice out unused elements num_objects = valid_detections.numpy()[0] bboxes = boxes.numpy()[0] bboxes = bboxes[0:int(num_objects)] scores = scores.numpy()[0] scores = scores[0:int(num_objects)] classes = classes.numpy()[0] classes = classes[0:int(num_objects)] # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, width, height original_h, original_w, _ = frame.shape bboxes = utils.format_boxes(bboxes, original_h, original_w) # store all predictions in one parameter for simplicity when calling functions pred_bbox = [bboxes, scores, classes, num_objects] #fps = 1.0 / (time.time() - start_time) #print("1-FPS: %.2f" % fps) # read in all class names from config class_names = utils.read_class_names(cfg.YOLO.CLASSES) # by default allow all classes in .names file #allowed_classes = list(class_names.values()) # custom allowed classes (uncomment line below to customize tracker for only people) allowed_classes = ['person'] # loop through objects and use class index to get class name, allow only classes in allowed_classes list names = [] deleted_indx = [] for i in range(num_objects): class_indx = int(classes[i]) class_name = class_names[class_indx] if class_name not in allowed_classes: deleted_indx.append(i) else: names.append(class_name) names = np.array(names) count = len(names) if FLAGS.count: cv2.putText(frame, "Objects being tracked: {}".format(count), (5, 35), cv2.FONT_HERSHEY_COMPLEX_SMALL, 2, (0, 255, 0), 2) print("Objects being tracked: {}".format(count)) # delete detections that are not in allowed_classes bboxes = np.delete(bboxes, deleted_indx, axis=0) scores = np.delete(scores, deleted_indx, axis=0) # encode yolo detections and feed to tracker features = encoder(frame, bboxes) detections = [ Detection(bbox, score, class_name, feature) for bbox, score, class_name, feature in zip( bboxes, scores, names, features) ] cmap = plt.get_cmap('tab20b') colors = [cmap(i)[:3] for i in np.linspace(0, 1, 20)] # run non-maxima supression boxs = np.array([d.tlwh for d in detections]) scores = np.array([d.confidence for d in detections]) classes = np.array([d.class_name for d in detections]) indices = preprocessing.non_max_suppression(boxs, classes, nms_max_overlap, scores) detections = [detections[i] for i in indices] # Call the tracker tracker.predict() tracker.update(detections, frame_num) # <st-mini 제어를 위한 Publisher code> go.update(x, y, z, th, speed, turn) # flag가 True라면 Target lost if tracker.lost: go.sendMsg(frame_num % 2) else: go.sendMsg(1) # 추적 알고리즘 if len(tracker.tracks) == 0: # 추적할 객체가 없다면 정지 key = 'stop' print('There are no objects to track.') else: # 추적할 객체가 있다면 동작 for track in tracker.tracks: if not track.is_confirmed() or track.time_since_update > 1: continue bbox = track.to_tlbr() class_name = track.get_class() # cx, cy 계산 추가 w, h = int(bbox[2] - bbox[0]), int(bbox[3] - bbox[1]) cx, cy = int(w / 2 + bbox[0]), int(h / 2 + bbox[1]) # 사람과 로봇의 거리: person_distance if not use_webcam: person_distance = person_dist(depth_frame, cx, cy, h) print('person distance : ', person_dist(depth_frame, cx, cy, h)) # 직진 안전 구간 최대/최소값 stable_max_dist = 2500 stable_min_dist = 2000 if person_distance < stable_min_dist: # 로봇과 사람의 거리가 직진 안전 구간 최솟값보다 작을 때 정지 print('Too Close') key = 'stop' else: """ depth값 활용 1. Target과의 거리[전진] 1) 적정거리: 2.0m ~ 2.5m --> linear.x = 0.7 2) 위험거리: ~2.0m --> linear.x = 0 3) 추격거리: 2.5m~ --> linear.x += 0.2 (적정거리가 될 때까지) 2. Target의 중심점을 이용해 좌우 회전 1) 중심점 cx, cy는 아래와 같이 구할 수 있다. width = bbox[2] - bbox[0] height = bbox[3] - bbox[1] cx = int(width/2 + bbox[0]) cy = int(height/2 + bbox[1]) 좌우 판단이기 때문에 cx만 사용. 2) cx값 설정 중 주의 사항 target이 화면 밖으로 점점 나갈수록 bbox의 좌측 상단 x좌표는 음수 혹은 frame width(여기서는 640)보다 커질 수 있다. 즉, cx의 값을 설정할 때 bbox[0]값이 음수 또는 640을 초과하면 좌우 회전 즉시 실시해야 함. depth camera를 통해 장애물 유무를 먼저 판단하고 없다면 Target과의 거리/방향 측정 후 최종 발행값 결정. """ # 장애물 회피용 ROI distance로 left, right string 받아오기(사람이 직진 최대 거리보다 멀때 장애물 판단) # if person_distance > stable_max_dist: key = obstacle_detect(default, depth_frame) cv2.rectangle(frame, (cx + 10, cy - (h // 5) + 10), (cx - 10, cy - (h // 5) - 10), (255, 0, 0), 5) # 장애물이 없다면 사람 따라가기 if key == None: print('key is NOT None') # key,speed,turn = drive(cx, left_limit, right_limit, turn, speed) # key,speed,turn = drive2(cx, left_limit, right_limit, turn, frame, speed, max_speed, max_turn) # key,speed,turn = drive3(cx, left_limit, right_limit, turn, frame, speed, max_speed, min_speed, max_turn, stable_min_dist, stable_max_dist, person_distance, start_speed_down=300) key, speed, turn = drive4(cx, left_limit, right_limit, turn, frame, speed, max_speed, min_speed, max_turn, stable_min_dist, stable_max_dist, person_distance, start_speed_down=300) # draw bbox on screen color = colors[int(track.track_id) % len(colors)] color = [i * 255 for i in color] cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), color, 2) cv2.rectangle( frame, (int(bbox[0]), int(bbox[1] - 30)), (int(bbox[0]) + (len(class_name) + len(str(track.track_id))) * 17, int(bbox[1])), color, -1) cv2.putText(frame, class_name + "-" + str(track.track_id), (int(bbox[0]), int(bbox[1] - 10)), 0, 0.75, (255, 255, 255), 2) # 주행 알고리즘(drive)를 거치고 나온 속도/방향을 로봇에 전달 x, y, z, th, speed, turn = key_move(key, x, y, z, th, speed, turn) print('key: ', key) print('key_type: ', type(key)) print('x: {}, y: {}, th: {}, speed: {}, turn: {}'.format( x, y, th, speed, turn)) # 화면 중심 표시 cv2.circle(frame, (320, 240), 10, (255, 255, 255)) # 좌우 회전 구분선 그리기 cv2.line(frame, (left_limit, 0), (left_limit, frame.shape[0]), (255, 0, 0)) cv2.line(frame, (right_limit, 0), (right_limit, frame.shape[0]), (255, 0, 0)) # ROS Rate sleep rate.sleep() ''' box_center_roi = np.array((depth_frame[cy-10:cy+10, cx-10:cx+10]),dtype=np.float64) cv2.rectangle(frame, (cx-10, cy+10), (cx+10, cy-10), (255, 255, 255), 2) ''' safe_roi = np.array([[400, 400], [240, 400], [160, 480], [480, 480]]) #safe_roi = np.array([[240, 420], [400, 420], [480, 160], [480, 480]]) cv2.polylines(frame, [safe_roi], True, (255, 255, 255), 2) cv2.rectangle(frame, (205, 445), (195, 435), (255, 0, 0), 5) cv2.rectangle(frame, (245, 405), (235, 395), (255, 0, 0), 5) cv2.rectangle(frame, (405, 405), (395, 395), (255, 0, 0), 5) cv2.rectangle(frame, (445, 445), (435, 435), (255, 0, 0), 5) # calculate frames per second of running detections fps = 1.0 / (time.time() - start_time) print("FPS: %.2f" % fps) # info = "time: %.2f ms" %(1000*(time.time() - start_time)) #print(info) result = np.asarray(frame) result = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) # depth map을 칼라로 보기위함 # depth_colormap = cv2.applyColorMap(cv2.convertScaleAbs(depth_frame, alpha=0.03), cv2.COLORMAP_JET) if not FLAGS.dont_show: cv2.imshow("Output Video", result) if cv2.waitKey(1) & 0xFF == ord('q'): dc.release() cv2.destroyAllWindows() break
def main(_argv): config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS) input_size = FLAGS.size if FLAGS.framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=FLAGS.weights) interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() print(input_details) print(output_details) else: saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] if FLAGS.output: # by default VideoCapture returns float instead of int width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = int(vid.get(cv2.CAP_PROP_FPS)) codec = cv2.VideoWriter_fourcc(*FLAGS.output_format) out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height)) frame_id = 0 while not rospy.is_shutdown(): frame = cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB) image = Image.fromarray(frame) # # return_value, frame = vid.read() # if return_value: # frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # image = Image.fromarray(frame) # else: # if frame_id == vid.get(cv2.CAP_PROP_FRAME_COUNT): # print("Video processing complete") # break # raise ValueError("No image! Try with another video format") frame_size = frame.shape[:2] image_data = cv2.resize(frame, (input_size, input_size)) image_data = image_data / 255. image_data = image_data[np.newaxis, ...].astype(np.float32) prev_time = time.time() if FLAGS.framework == 'tflite': interpreter.set_tensor(input_details[0]['index'], image_data) interpreter.invoke() pred = [ interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details)) ] if FLAGS.model == 'yolov3' and FLAGS.tiny == True: boxes, pred_conf = filter_boxes(pred[1], pred[0], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: batch_data = tf.constant(image_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=FLAGS.iou, score_threshold=FLAGS.score) pred_bbox = [ boxes.numpy(), scores.numpy(), classes.numpy(), valid_detections.numpy() ] image = utils.draw_bbox(frame, pred_bbox) curr_time = time.time() exec_time = curr_time - prev_time result = np.asarray(image) info = "time: %.2f ms" % (1000 * exec_time) info = "fps: %.2f" % (1. / exec_time) print(info) image_h, image_w, _ = frame.shape out_boxes, out_scores, out_classes, num_boxes = pred_bbox ROI_array_msg = ROI_array() for i in range(num_boxes[0]): if int(out_classes[0][i]) < 0 or int( out_classes[0][i]) > NUM_CLASS: continue ROI_msg = ROI() coor = out_boxes[0][i] ROI_msg.min_x = int(coor[1]) #x min ROI_msg.min_y = int(coor[0]) #y min ROI_msg.Max_x = int(coor[3]) #x max ROI_msg.Max_y = int(coor[2]) #y max ROI_msg.score = float(out_scores[0][i]) ROI_msg.object_name = str(class_name[int(out_classes[0][i])]) ROI_array_msg.ROI_list.append(ROI_msg) roi_array_pub.publish(ROI_array_msg) result = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) if not FLAGS.dis_cv2_window: cv2.namedWindow("result", cv2.WINDOW_AUTOSIZE) cv2.imshow("result", result) if cv2.waitKey(1) & 0xFF == ord('q'): break if FLAGS.output: out.write(result) frame_id += 1
if not config['Shuffle']['random']: SEED = config['Shuffle']['seed'] from numpy.random import seed seed(SEED) import tensorflow as tf tf.random.set_seed(SEED) from random import seed seed(SEED) #############################################SOLUCIONAR EL ERROR DE LA LIBRERIA CUDNN################################### from tensorflow.compat.v1 import ConfigProto from tensorflow.compat.v1 import InteractiveSession configProto = ConfigProto() configProto.gpu_options.allow_growth = True session = InteractiveSession(config=configProto) #Se añade el directorio utilities a sys.path para que pueda ser usaado por el comando import sys.path.append(os.path.join(rootdir, 'utilities')) from os.path import join import json import numpy as np from pathlib import Path import models_Shuffle import DataGenerators_Shuffle from FuncionesAuxiliares import read_instance_file_txt
def main(_argv): config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS) input_size = FLAGS.size image_folder = FLAGS.image_folder file_list = os.listdir(image_folder) for process, image_name in enumerate(file_list): image_path = os.path.join(image_folder, image_name) print(image_path, '****', process + 1, '/', len(file_list)) original_image = cv2.imread(image_path) original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB) # image_data = utils.image_preprocess(np.copy(original_image), [input_size, input_size]) image_data = cv2.resize(original_image, (input_size, input_size)) image_data = image_data / 255. # image_data = image_data[np.newaxis, ...].astype(np.float32) images_data = [] for i in range(1): images_data.append(image_data) images_data = np.asarray(images_data).astype(np.float32) if FLAGS.framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=FLAGS.weights) interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() print(input_details) print(output_details) interpreter.set_tensor(input_details[0]['index'], images_data) interpreter.invoke() pred = [ interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details)) ] if FLAGS.model == 'yolov3' and FLAGS.tiny == True: boxes, pred_conf = filter_boxes(pred[1], pred[0], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: saved_model_loaded = tf.saved_model.load( FLAGS.weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] batch_data = tf.constant(images_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=FLAGS.iou, score_threshold=FLAGS.score) pred_bbox = [ boxes.numpy(), scores.numpy(), classes.numpy(), valid_detections.numpy() ] ####################################### boxes = boxes.numpy().squeeze() scores = scores.numpy().squeeze() scores = np.array([scores]).T boxes_scores = np.concatenate((boxes, scores), axis=1) boxes_scores = boxes_scores[:valid_detections.numpy()[0], :] multiplier = np.array([ original_image.shape[0], original_image.shape[1], original_image.shape[0], original_image.shape[1], 10000 ]).T boxes_scores = boxes_scores * multiplier boxes_scores_int = np.around(boxes_scores).astype(np.int16) image_name = image_name.replace('.jpg', '') txt_path = image_folder + '/' + image_name + '.txt' np.savetxt(txt_path, boxes_scores_int, fmt='%i') # lt y,x 비율 rb y,x 비율 _score image = utils.draw_bbox(original_image, pred_bbox) # image = utils.draw_bbox(image_data*255, pred_bbox) image = Image.fromarray(image.astype(np.uint8)) image.show() image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB) result_path = image_folder + '/' + image_name + '.png' cv2.imwrite(result_path, image)
def main(_argv): config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS) input_size = FLAGS.size video_path = FLAGS.video # get video name by using split method video_name = video_path.split('/')[-1] video_name = video_name.split('.')[0] if FLAGS.framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=FLAGS.weights) interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() print(input_details) print(output_details) else: saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] # begin video capture try: vid = cv2.VideoCapture(int(video_path)) except: vid = cv2.VideoCapture(video_path) out = None if FLAGS.output: # by default VideoCapture returns float instead of int width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = int(vid.get(cv2.CAP_PROP_FPS)) codec = cv2.VideoWriter_fourcc(*FLAGS.output_format) out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height)) frame_num = 0 while True: return_value, frame = vid.read() if return_value: frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) frame_num += 1 image = Image.fromarray(frame) else: print('Video has ended or failed, try a different video format!') break frame_size = frame.shape[:2] image_data = cv2.resize(frame, (input_size, input_size)) image_data = image_data / 255. image_data = image_data[np.newaxis, ...].astype(np.float32) start_time = time.time() batch_data = tf.constant(image_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=FLAGS.iou, score_threshold=FLAGS.score ) # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, xmax, ymax original_h, original_w, _ = frame.shape bboxes = utils.format_boxes(boxes.numpy()[0], original_h, original_w) pred_bbox = [bboxes, scores.numpy()[0], classes.numpy()[0], valid_detections.numpy()[0]] # custom allowed classes (uncomment line below to allow detections for only people) classes = ['chair', 'person'] # count objects found counted_classes = count_objects(pred_bbox, by_class = True, allowed_classes=classes) # loop through dict and print for key, value in counted_classes.items(): print("Number of {}s: {}".format(key, value)) image = utils.draw_bbox(frame, pred_bbox, FLAGS.info, counted_classes, allowed_classes=classes, read_plate=FLAGS.plate) cv2.putText(image, "Chairs Expected: 48", (5, 75), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (255, 0, 0), 2) cv2.putText(image, "Students Expected: 4", (5, 50), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (255, 0, 0), 2) fps = 1.0 / (time.time() - start_time) print("FPS: %.2f" % fps) cv2.putText(image, "FPS: {}".format(fps), (850, 20), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (255, 0, 0), 2) result = np.asarray(image) cv2.namedWindow("result", cv2.WINDOW_AUTOSIZE) result = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) if not FLAGS.dont_show: cv2.imshow("result", result) if FLAGS.output: out.write(result) if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.destroyAllWindows()
def main(_argv): config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS) input_size = FLAGS.size # image_path = FLAGS.image # original_image = cv2.imread(image_path) original_image = cv2.cvtColor(video_frame, cv2.COLOR_BGR2RGB) # image_data = utils.image_preprocess(np.copy(original_image), [input_size, input_size]) image_data = cv2.resize(original_image, (input_size, input_size)) image_data = image_data / 255. # image_data = image_data[np.newaxis, ...].astype(np.float32) images_data = [] for i in range(1): images_data.append(image_data) images_data = np.asarray(images_data).astype(np.float32) if FLAGS.framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=FLAGS.weights) interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() print(input_details) print(output_details) interpreter.set_tensor(input_details[0]['index'], images_data) interpreter.invoke() pred = [ interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details)) ] if FLAGS.model == 'yolov3' and FLAGS.tiny == True: boxes, pred_conf = filter_boxes(pred[1], pred[0], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] batch_data = tf.constant(images_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=FLAGS.iou, score_threshold=FLAGS.score) final_boxes = boxes.numpy() final_scores = scores.numpy() final_classes = classes.numpy() array_boxes_detected = get_human_box_detection(final_boxes, final_scores[0].tolist(), final_classes[0].tolist(), original_image.shape[0], original_image.shape[1]) print(array_boxes_detected) #Defining red color rgb value COLOR_RED = (0, 0, 255) for i, items in enumerate(array_boxes_detected): first_point = array_boxes_detected[i][0] second_point = array_boxes_detected[i][1] third_point = array_boxes_detected[i][2] fourth_point = array_boxes_detected[i][3] cv2.rectangle(original_image, (second_point, first_point), (fourth_point, third_point), COLOR_RED, 2) image = cv2.cvtColor(np.array(original_image), cv2.COLOR_BGR2RGB) cv2.imshow("final", image) cv2.waitKey(0)
def create_session(self): print("[*] Settings config ..") config = ConfigProto() config.gpu_options.allow_growth = True self.session = InteractiveSession(config=config) print("[*] Done")
def main(_argv): # Definition of the parameters max_cosine_distance = 0.4 nn_budget = None nms_max_overlap = 1.0 # initialize deep sort model_filename = 'model_data/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename, batch_size=1) # calculate cosine distance metric metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) # initialize deepsort tracker tracker = Tracker(metric) # load configuration for object detector config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS) input_size = 416 # load model saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] out = None ### csv config ### a = 30 calc_stop = 0 filename = datetime.now().strftime('%d_%m_%y') filename = 'data/data_log/csv_log/{}.csv'.format(filename) ### heatmap config ### heatmap = [] # heatmap which gets incremented over the day for i in range(len(lots)): numlot = [0] * len(lots[i]) heatmap.append(numlot) ### server data config ### unique_cars = [] ### intervall config ### imageProcessingInterval = 20 # default imageProcessing interval in seconds lastProcessed = time.time() # last processed image last_round = [ ] # initialize last_round which stores last round taken_lot config # while video is running while True: # processes frame only in given time interval if lastProcessed + imageProcessingInterval < time.time(): try: lastProcessed = time.time() frames = [] vid = cv2.VideoCapture( "http://96.56.250.139:8200/mjpg/video.mjpg") if not vid.isOpened(): raise IOError("We cannot open webcam", spots[s]) return_value, frame = vid.read() if return_value: frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) image = Image.fromarray(frame) else: print( 'Video has ended or failed, try a different video format!' ) # since the whole loop is in a try-block loop doesnt need to break # which makes the script more robust for temporary camera or internet connection errors #break # crop all camera frames to same width to add them to one window y = spots[0]["crop"][ 'y'] # todo: replace '3' with 'i' for data.json loop x = spots[0]["crop"]['x'] h = 600 w = 600 frame = frame[y:y + h, x:x + w] frame_size = frame.shape[:2] image_data = cv2.resize(frame, (input_size, input_size)) image_data = image_data / 255. image_data = image_data[np.newaxis, ...].astype(np.float32) start_time = time.time() # batch_data = tf.constant(image_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=FLAGS.iou, score_threshold=FLAGS.score) # convert data to numpy arrays and slice out unused elements num_objects = valid_detections.numpy()[0] bboxes = boxes.numpy()[0] bboxes = bboxes[0:int(num_objects)] scores = scores.numpy()[0] scores = scores[0:int(num_objects)] classes = classes.numpy()[0] classes = classes[0:int(num_objects)] # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, width, height original_h, original_w, _ = frame.shape bboxes = utils.format_boxes(bboxes, original_h, original_w) # store all predictions in one parameter for simplicity when calling functions pred_bbox = [bboxes, scores, classes, num_objects] # read in all class names from config class_names = utils.read_class_names(cfg.YOLO.CLASSES) # by default allow all classes in .names file allowed_classes = list(class_names.values()) # loop through objects and use class index to get class name names = [] for i in range(num_objects): class_indx = int(classes[i]) class_name = class_names[class_indx] names.append(class_name) names = np.array(names) # encode yolo detections and feed to tracker features = encoder(frame, bboxes) detections = [ Detection(bbox, score, class_name, feature) for bbox, score, class_name, feature in zip( bboxes, scores, names, features) ] # initialize color map cmap = plt.get_cmap('tab20b') colors = [cmap(i)[:3] for i in np.linspace(0, 1, 20)] # run non-maxima supression boxs = np.array([d.tlwh for d in detections]) scores = np.array([d.confidence for d in detections]) classes = np.array([d.class_name for d in detections]) indices = preprocessing.non_max_suppression( boxs, classes, nms_max_overlap, scores) detections = [detections[i] for i in indices] # call the tracker tracker.predict() tracker.update(detections) # update tracks car_boxes = [] # cars as box polygon for track in tracker.tracks: if not track.is_confirmed() or track.time_since_update > 1: continue bbox = track.to_tlbr() class_name = track.get_class() # draw bbox with tracking id on screen color = colors[int(track.track_id) % len(colors)] color = [i * 255 for i in color] cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), color, 2) cv2.rectangle( frame, (int(bbox[0]), int(bbox[1] - 30)), (int(bbox[0]) + (len(class_name) + len(str(track.track_id))) * 17, int(bbox[1])), color, -1) cv2.putText(frame, class_name + "-" + str(track.track_id), (int(bbox[0]), int(bbox[1] - 10)), 0, 0.5, (255, 255, 255), 2) xmin, ymin, xmax, ymax, car_id = int(bbox[0]), int( bbox[1]), int(bbox[2]), int(bbox[3]), track.track_id car = box(xmin, ymin, xmax, ymax) car_boxes.append([car, car_id]) car_boxes = np.array(car_boxes) taken_lots = { # dict stores all taken lots of current analysis round 'lot_ids': [], 'car_ids': [], 'timespan': [] } print("\n######### new round ##############") s = 0 # todo: add data.json-loop to loop through multiple cameras in one analysing session for i in range(len( lots[s])): # loop through all lots of parking space # set each parking lot to 'free' as default and change if is blocked lines = green free = '1' cords = np.array( lots[s][i]['cords'], np.int32 ) # format coordinates to numpy array with 32-bits ints x1, y1 = cords[0] l = Polygon(cords) lot_id = lots[s][i]['id'] for j in range(len(car_boxes)): # loop through all cars c = car_boxes[j][0] # each detected car car_id = car_boxes[j][1] # each detected car intsec = c.intersection( l).area # intersection of each car with this lot # print(round(int)) r = round(intsec / l.area, 2) # print(f" car-{j}: {r}") ### lot is blocked ### if r > .5: # minimum percentage of how much of the lot neeeds to be blocked lines = red free = '0' # increment heatmap index for parking-lot i heatmap[s][i] += 1 # add car id, if new/unique to count unique visitors of day if not car_id in unique_cars: unique_cars.append(car_id) # save taken lot information in taken_lot dict taken_lots['lot_ids'].append(lot_id) taken_lots['car_ids'].append(car_id) # print("\nlot_id", lot_id) # check if lot is still blocked by same car try: # car was blocking this lot already in last round lot_index = last_round['lot_ids'].index( str(lot_id) ) # searches for current lot in last_round if car_id == last_round['car_ids'][lot_index]: # lot is still blocked by same car timespan = last_round['timespan'][ lot_index] # print("still blocked by car", car_id) else: # lot is blocked by new car (id) now = datetime.now() now = now.strftime('%H:%M') timespan = now # saving blocking_time to current time # print("now blocked by car", car_id) except: # new car is blocking this lot print("new car - lot_id", lot_id) now = datetime.now() now = now.strftime('%H:%M') timespan = now # saving blocking_time to current time # print("now blocked by car", car_id) finally: # update array with appropriate timespan taken_lots['timespan'].append(timespan) ### finally ### #taken_lots.append(lot_id) break # break car loop for this lot, bc it is blocked by a car cv2.drawContours(frame, [cords], -1, lines, 3) # draw lot in correct color cv2.putText(frame, lot_id, (x1 + 10, y1 + 20), cv2.FONT_HERSHEY_SIMPLEX, .6, black, 1) #### update databases #### # print last updated timestamp on camerascreen now = datetime.now().strftime('%H:%M:%S') cv2.putText(frame, now, (50, 50), cv2.FONT_HERSHEY_SIMPLEX, .6, red, 2) if FLAGS.update_server: print("Update Server:", now) # update_json(spots[s]["id"], taken_lots, heatmap[s], now) # update_server("daily_usage.json", len(taken_lots['lot_ids'])) # update_server("total_usage.json", len(unique_cars)) # update_server("heatmap.json", heatmap[s]) heatmap[s] = [0] * len(lots[s]) # reset heatmap array # write round to csv --> if its before 00:00 if calc_stop > time.time(): print("Update CSV:", now) # create list for csv lot_ids = taken_lots['lot_ids'] car_ids = taken_lots['car_ids'] csv_row = [datetime.now().strftime('%H:%M')] for i in range(len(lots[s])): try: ind = lot_ids.index(str(i)) csv_row.append(car_ids[ind]) # print("added") except ValueError: csv_row.append(0) # print("not inside") # Append a list as new line to an old csv file append_csv_as_row(filename, csv_row) # create new csv and start round for day else: unique_cars = [] # reset unique car count on midnight print("reset Heatmap") FMT = '%H:%M:%S' a += 10 #debug: create new csv every x minutes release_time = '00:00:00'.format(a) # end time #release_time = '19:00:00'.format(a) # end time release_time = datetime.strptime(release_time, FMT) now = datetime.now().strftime("%H:%M:%S") now = datetime.strptime(now, FMT) tdelta = release_time - now calc_stop = time.time() + tdelta.seconds #print("seconds until calc_stop:", tdelta.seconds) print("create new CSV") filename = datetime.now().strftime('%d_%m_%y') filename = 'data/data_log/csv_log/{}.csv'.format(filename) print(filename) with open(filename, 'a+', newline='') as write_obj: # Create a writer object from csv module list_of_elem = ['timestamp'] for i in range(len(lots[s])): list_of_elem.append("lot{}".format(i)) csv_writer = csv.writer(write_obj) # Add contents of list as last row in the csv file csv_writer.writerow(list_of_elem) write_obj.close() last_round = taken_lots # save taken_lots of round in "last" round # add analysed frame to window of all analysed cameras from data.json frames.append(frame) if FLAGS.fps: # calculate frames per second of running detections fps = 1.0 / (time.time() - start_time) print("FPS: %.2f" % fps) result = np.asarray(frame) result = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) if not FLAGS.dont_show: cv2.imshow("Parking Lot Video", result) if FLAGS.save_img: # save analysed img to local directory for manual evaluation of accuracy save_analysed_img(result) except Exception as err: print("----- Couldn't process frame ----") print(err) if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.destroyAllWindows()
def configure_gpu(): conf = ConfigProto() conf.gpu_options.allow_growth = True conf.gpu_options.per_process_gpu_memory_fraction = config.PER_PROCESS_GPU_MEMORY_FRACTION session = InteractiveSession(config=conf)
def main(_argv): avg = [] # Definition of the parameters max_cosine_distance = 0.4 nn_budget = None nms_max_overlap = 1.0 #regression model load weight_path = './2_input_model_2-3.5%/' loaded_model = tf.keras.models.load_model(weight_path) # initialize deep sort model_filename = 'model_data/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename, batch_size=1) # calculate cosine distance metric metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) # initialize tracker tracker = Tracker(metric) # load configuration for object detector config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS) input_size = FLAGS.size video_path = FLAGS.video # load tflite model if flag is set if FLAGS.framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=FLAGS.weights) interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() print(input_details) print(output_details) # otherwise load standard tensorflow saved model else: saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] # begin video capture try: vid = cv2.VideoCapture(int(video_path)) except: vid = cv2.VideoCapture(video_path) out = None # get video ready to save locally if flag is set if FLAGS.output: # by default VideoCapture returns float instead of int width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = int(vid.get(cv2.CAP_PROP_FPS)) codec = cv2.VideoWriter_fourcc(*FLAGS.output_format) out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height)) frame_num = 0 # while video is running while True: return_value, frame = vid.read() if return_value: frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) image = Image.fromarray(frame) else: print('Video has ended or failed, try a different video format!') break frame_num += 1 print('Frame #: ', frame_num) frame_size = frame.shape[:2] image_data = cv2.resize(frame, (input_size, input_size)) image_data = image_data / 255. image_data = image_data[np.newaxis, ...].astype(np.float32) start_time = time.time() # run detections on tflite if flag is set if FLAGS.framework == 'tflite': interpreter.set_tensor(input_details[0]['index'], image_data) interpreter.invoke() pred = [ interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details)) ] # run detections using yolov3 if flag is set if FLAGS.model == 'yolov3' and FLAGS.tiny == True: boxes, pred_conf = filter_boxes(pred[1], pred[0], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: batch_data = tf.constant(image_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=FLAGS.iou, score_threshold=FLAGS.score) # convert data to numpy arrays and slice out unused elements num_objects = valid_detections.numpy()[0] bboxes = boxes.numpy()[0] bboxes = bboxes[0:int(num_objects)] scores = scores.numpy()[0] scores = scores[0:int(num_objects)] classes = classes.numpy()[0] classes = classes[0:int(num_objects)] # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, width, height original_h, original_w, _ = frame.shape bboxes = utils.format_boxes(bboxes, original_h, original_w) # store all predictions in one parameter for simplicity when calling functions pred_bbox = [bboxes, scores, classes, num_objects] #print("pred_bbox: ",pred_bbox[0]) #print("scores: ",pred_bbox[1]) #print("classes :",pred_bbox[2]) #print("num :",pred_bbox[3]) #print("width :",width) #print("height :",height) # read in all class names from config class_names = utils.read_class_names(cfg.YOLO.CLASSES) # by default allow all classes in .names file allowed_classes = list(class_names.values()) # custom allowed classes (uncomment line below to customize tracker for only people) #allowed_classes = ['person'] # loop through objects and use class index to get class name, allow only classes in allowed_classes list names = [] deleted_indx = [] for i in range(num_objects): class_indx = int(classes[i]) class_name = class_names[class_indx] if class_name not in allowed_classes: deleted_indx.append(i) else: names.append(class_name) names = np.array(names) count = len(names) if FLAGS.count: cv2.putText(frame, "Objects being tracked: {}".format(count), (5, 35), cv2.FONT_HERSHEY_COMPLEX_SMALL, 2, (0, 255, 0), 2) print("Objects being tracked: {}".format(count)) # delete detections that are not in allowed_classes bboxes = np.delete(bboxes, deleted_indx, axis=0) scores = np.delete(scores, deleted_indx, axis=0) # encode yolo detections and feed to tracker features = encoder(frame, bboxes) detections = [ Detection(bbox, score, class_name, feature) for bbox, score, class_name, feature in zip( bboxes, scores, names, features) ] #initialize color map cmap = plt.get_cmap('tab20b') colors = [cmap(i)[:3] for i in np.linspace(0, 1, 20)] # run non-maxima supression boxs = np.array([d.tlwh for d in detections]) scores = np.array([d.confidence for d in detections]) classes = np.array([d.class_name for d in detections]) #print("boxs ",boxs) #print("scores ",scores) #print("classes ",classes) indices = preprocessing.non_max_suppression(boxs, classes, nms_max_overlap, scores) #print("indices ",indices) detections = [detections[i] for i in indices] # Call the tracker tracker.predict() tracker.update(detections) cv2.putText(frame, "using regress", (5, 35), cv2.FONT_HERSHEY_COMPLEX_SMALL, 2, (255, 0, 255), 2) #cv2.putText(frame, "Objects being detected: {}".format(count), (5, 350), cv2.FONT_HERSHEY_COMPLEX_SMALL, 2, (0, 0, 255), 2) cv2.putText(frame, "frame# {}".format(frame_num), (750, 35), cv2.FONT_HERSHEY_COMPLEX_SMALL, 2, (255, 0, 255), 2) # update tracks for track in tracker.tracks: if not track.is_confirmed() or track.time_since_update > 1: continue bbox = track.to_tlbr() class_name = track.get_class() if 'entrance' not in classes: if len(classes) > 1: if (contains_duplicates(classes) == False): #color = (50, 89, 170) check_rect = 0 width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)) ########## set sticker as low priority############# if ((classes[0] == 'mat' or 'sensor') and (classes[1] == 'mat' or 'sensor')): print( "*************NO STK**********************************" ) color = (50, 89, 170) x1, y1, x2, y2 = convert2( width, height, int(boxs[0][0]), int(boxs[0][1]), int(boxs[0][0] + boxs[0][2]), int(boxs[0][1] + boxs[0][3])) #xywh to xmin ymin xmax ymax x3, y3, x4, y4 = convert2( width, height, int(bboxes[1][0]), int(bboxes[1][1]), int(bboxes[1][0] + bboxes[1][2]), int(bboxes[1][1] + bboxes[1][3] )) #xywh to xmin ymin xmax ymax reg_input = np.array([[ class_index(classes[0]), x1, y1, x2, y2, class_index(classes[1]), x3, y3, x4, y4 ]]) predictions = loaded_model.predict(reg_input) a1_pred = predictions[0] b1_pred = predictions[1] c1_pred = predictions[2] d1_pred = predictions[3] xmin, xmax, ymin, ymax = convert( width, height, a1_pred, b1_pred, c1_pred, d1_pred) start_point = (xmin, ymin) end_point = (xmax, ymax) rect1 = xmax - xmin rect2 = ymax - ymin check_rect = rect2 / rect1 ################ else condition for sticker ###### else: print( "*************USE STK**********************************" ) if ((classes[0] == 'famSticker' or 'okmartSticker' or 'sevenSticker')): color = (60, 120, 40) x1, y1, x2, y2 = convert2( width, height, int(boxs[0][0]), int(boxs[0][1]), int(boxs[0][0] + boxs[0][2]), int(boxs[0][1] + boxs[0][3]) ) #xywh to xmin ymin xmax ymax x3, y3, x4, y4 = convert2( width, height, int(bboxes[1][0]), int(bboxes[1][1]), int(bboxes[1][0] + bboxes[1][2]), int(bboxes[1][1] + bboxes[1][3]) ) #xywh to xmin ymin xmax ymax reg_input = np.array([[ class_index(classes[0]), x1, y1, x2, y2, class_index(classes[1]), x3, y3, x4, y4 ]]) #### rario #### C1_x = boxs[0][0] + (boxs[0][2] / 2) C1_y = boxs[0][1] + (boxs[0][3] / 2) C2_x = bboxes[1][0] + (bboxes[1][2] / 2) C2_y = bboxes[1][1] + (bboxes[1][3] / 2) Dx = (C2_x - C1_x) Dy = (C2_y - C1_y) #The two rectangles do not intersect, and there are two rectangles partially overlapping in the X-axis direction. The minimum distance is the distance between the lower line of the upper rectangle and the upper line of the lower rectangle if ((Dx < ((int(boxs[0][0] + boxs[0][2]) + int(bboxes[1][0] + bboxes[1][2])) / 2)) and (Dy >= ((int(boxs[0][1] + boxs[0][3]) + rint(bboxes[1][1] + bboxes[1][3])) / 2))): min_dist = Dy - ( (int(boxs[0][1] + boxs[0][3]) + int(bboxes[1][1] + bboxes[1][3])) / 2) #The two rectangles do not intersect. There are two partially overlapping rectangles in the Y-axis direction. The minimum distance is the distance between the right line of the left rectangle and the left line of the right rectangle elif ( (Dx >= ((int(boxs[0][0] + boxs[0][2]) + int(bboxes[1][0] + bboxes[1][2])) / 2)) and (Dy < ((int(boxs[0][1] + boxs[0][3]) + int(bboxes[1][1] + bboxes[1][3])) / 2))): min_dist = Dx - ( (int(boxs[0][0] + boxs[0][2]) + int(bboxes[1][0] + bboxes[1][2])) / 2) #Two rectangles do not intersect, two rectangles that do not overlap in the X-axis and Y-axis directions, the minimum distance is the distance between the two closest vertices, # Using the Pythagorean theorem, it is easy to calculate this distance elif ( (Dx >= ((int(boxs[0][0] + boxs[0][2]) + int(bboxes[1][0] + bboxes[1][2])) / 2)) and (Dy >= ((int(boxs[0][1] + boxs[0][3]) + int(bboxes[1][1] + bboxes[1][3])) / 2))): delta_x = Dx - ( (int(boxs[0][0] + boxs[0][2]) + int(bboxes[1][0] + bboxes[1][2])) / 2) delta_y = Dy - ( (int(boxs[0][1] + boxs[0][3]) + int(bboxes[1][1] + bboxes[1][3])) / 2) min_dist = sqrt(delta_x * delta_x + delta_y * delta_y) #The intersection of two rectangles, the minimum distance is negative, return -1 else: min_dist = -1 if (classes[1] == 'mat'): if ((min_dist / Dy) < 3): predictions = loaded_model.predict( reg_input) a1_pred = predictions[0] b1_pred = predictions[1] c1_pred = predictions[2] d1_pred = predictions[3] xmin, xmax, ymin, ymax = convert( width, height, a1_pred, b1_pred, c1_pred, d1_pred) start_point = (xmin, ymin) end_point = (xmax, ymax) rect1 = xmax - xmin rect2 = ymax - ymin check_rect = rect2 / rect1 else: print("not predict") elif (classes[1] == 'sensor'): if ((min_dist / Dx) < 3): predictions = loaded_model.predict( reg_input) a1_pred = predictions[0] b1_pred = predictions[1] c1_pred = predictions[2] d1_pred = predictions[3] xmin, xmax, ymin, ymax = convert( width, height, a1_pred, b1_pred, c1_pred, d1_pred) start_point = (xmin, ymin) end_point = (xmax, ymax) rect1 = xmax - xmin rect2 = ymax - ymin check_rect = rect2 / rect1 else: print("not predict") elif ((classes[1] == 'famSticker' or 'okmartSticker' or 'sevenSticker')): color = (60, 120, 40) x1, y1, x2, y2 = convert2( width, height, int(boxs[0][0]), int(boxs[0][1]), int(boxs[0][0] + boxs[0][2]), int(boxs[0][1] + boxs[0][3]) ) #xywh to xmin ymin xmax ymax x3, y3, x4, y4 = convert2( width, height, int(bboxes[1][0]), int(bboxes[1][1]), int(bboxes[1][0] + bboxes[1][2]), int(bboxes[1][1] + bboxes[1][3]) ) #xywh to xmin ymin xmax ymax reg_input = np.array([[ class_index(classes[0]), x1, y1, x2, y2, class_index(classes[1]), x3, y3, x4, y4 ]]) #### rario #### C1_x = boxs[0][0] + (boxs[0][2] / 2) C1_y = boxs[0][1] + (boxs[0][3] / 2) C2_x = bboxes[1][0] + (bboxes[1][2] / 2) C2_y = bboxes[1][1] + (bboxes[1][3] / 2) Dx = (C2_x - C1_x) Dy = (C2_y - C1_y) #The two rectangles do not intersect, and there are two rectangles partially overlapping in the X-axis direction. The minimum distance is the distance between the lower line of the upper rectangle and the upper line of the lower rectangle if ((Dx < ((int(boxs[0][0] + boxs[0][2]) + int(bboxes[1][0] + bboxes[1][2])) / 2)) and (Dy >= ((int(boxs[0][1] + boxs[0][3]) + rint(bboxes[1][1] + bboxes[1][3])) / 2))): min_dist = Dy - ( (int(boxs[0][1] + boxs[0][3]) + int(bboxes[1][1] + bboxes[1][3])) / 2) #The two rectangles do not intersect. There are two partially overlapping rectangles in the Y-axis direction. The minimum distance is the distance between the right line of the left rectangle and the left line of the right rectangle elif ( (Dx >= ((int(boxs[0][0] + boxs[0][2]) + int(bboxes[1][0] + bboxes[1][2])) / 2)) and (Dy < ((int(boxs[0][1] + boxs[0][3]) + int(bboxes[1][1] + bboxes[1][3])) / 2))): min_dist = Dx - ( (int(boxs[0][0] + boxs[0][2]) + int(bboxes[1][0] + bboxes[1][2])) / 2) #Two rectangles do not intersect, two rectangles that do not overlap in the X-axis and Y-axis directions, the minimum distance is the distance between the two closest vertices, # Using the Pythagorean theorem, it is easy to calculate this distance elif ( (Dx >= ((int(boxs[0][0] + boxs[0][2]) + int(bboxes[1][0] + bboxes[1][2])) / 2)) and (Dy >= ((int(boxs[0][1] + boxs[0][3]) + int(bboxes[1][1] + bboxes[1][3])) / 2))): delta_x = Dx - ( (int(boxs[0][0] + boxs[0][2]) + int(bboxes[1][0] + bboxes[1][2])) / 2) delta_y = Dy - ( (int(boxs[0][1] + boxs[0][3]) + int(bboxes[1][1] + bboxes[1][3])) / 2) min_dist = sqrt(delta_x * delta_x + delta_y * delta_y) #The intersection of two rectangles, the minimum distance is negative, return -1 else: min_dist = -1 if (classes[0] == 'mat'): if ((min_dist / Dy) < 3): predictions = loaded_model.predict( reg_input) a1_pred = predictions[0] b1_pred = predictions[1] c1_pred = predictions[2] d1_pred = predictions[3] xmin, xmax, ymin, ymax = convert( width, height, a1_pred, b1_pred, c1_pred, d1_pred) start_point = (xmin, ymin) end_point = (xmax, ymax) rect1 = xmax - xmin rect2 = ymax - ymin check_rect = rect2 / rect1 else: print("not predict") elif (classes[0] == 'sensor'): if ((min_dist / Dx) < 3): predictions = loaded_model.predict( reg_input) a1_pred = predictions[0] b1_pred = predictions[1] c1_pred = predictions[2] d1_pred = predictions[3] xmin, xmax, ymin, ymax = convert( width, height, a1_pred, b1_pred, c1_pred, d1_pred) start_point = (xmin, ymin) end_point = (xmax, ymax) rect1 = xmax - xmin rect2 = ymax - ymin check_rect = rect2 / rect1 else: print("not predict") ############## ########################################## ######## check door size and display #########if check_rect>1 and frame_num !=104: print("check_rect:{}".format(check_rect)) if check_rect > 1: blk = np.zeros(frame.shape, np.uint8) cv2.rectangle(blk, start_point, end_point, color, cv2.FILLED) frame = cv2.addWeighted(frame, 1.0, blk, 0.5, 1) print( "predict_BBox Coords (xmin, ymin, xmax, ymax): {}" .format((xmin, ymin, xmax, ymax))) else: print("not show predicted bbox") ############################### ######## # select one entrace ######## #if classes.count('entrance')>1: # entrance_num=[] # iou_list=[] # iou_check=[] # for i in range(len(classes)): # if classes[i]=='entrance' # entrance_num.append(i) # if len(classes)>1: # if(contains_duplicates(classes)==False): # color = (50, 89, 170) # width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)) # height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)) # x1,y1,x2,y2=convert2(width,height,int(boxs[0][0]),int(boxs[0][1]),int(boxs[0][0]+boxs[0][2]),int(boxs[0][1]+boxs[0][3]))#xywh to xmin ymin xmax ymax # x3,y3,x4,y4=convert2(width,height,int(bboxes[1][0]),int(bboxes[1][1]),int(bboxes[1][0]+bboxes[1][2]),int(bboxes[1][1]+bboxes[1][3]))#xywh to xmin ymin xmax ymax # reg_input=np.array([[class_index(classes[0]),x1,y1,x2,y2,class_index(classes[1]),x3,y3,x4,y4]]) # predictions = loaded_model.predict(reg_input) # a1_pred = predictions[0] # b1_pred = predictions[1] # c1_pred = predictions[2] # d1_pred = predictions[3] # xmin,xmax,ymin,ymax=convert(width,height,a1_pred,b1_pred,c1_pred,d1_pred) # ###IOU### # GT_bbox_area = (xmax - xmin + 1) * ( ymax -ymin + 1) # ########### # ##check entrace## # Pred_bbox_area =(x_bottomright_p - x_topleft_p + 1 ) * ( y_bottomright_p -y_topleft_p + 1) # x_top_left =np.max([x_topleft_gt, x_topleft_p]) # y_top_left = np.max([y_topleft_gt, y_topleft_p]) # x_bottom_right = np.min([x_bottomright_gt, x_bottomright_p]) # y_bottom_right = np.min([y_bottomright_gt, y_bottomright_p]) # # intersection_area = (x_bottom_right- x_top_left + 1) * (y_bottom_right-y_top_left + 1) # # union_area = (GT_bbox_area + Pred_bbox_area - intersection_area) # # iou_check.append(intersection_area/union_area) # # for j in len(iou_check): # if entrance_num[j]<iou_check.max: # track.delete #if(int(track.track_id)>=3 or (int(track.track_id)>10 and int(track.track_id)<20 ) ): #frame_num ###################### draw bbox on screen color = colors[int(track.track_id) % len(colors)] color = [i * 255 for i in color] if (class_name == 'entrance'): if (int(track.track_id) == 1 and frame_num > 121): print("skip Tracker ID: {}, Class: {}".format( str(track.track_id), class_name)) else: print("RED Tracker ID: {}, Class: {}".format( str(track.track_id), class_name)) blk = np.zeros(frame.shape, np.uint8) cv2.rectangle(blk, (int(bbox[0] * 1.05), int(bbox[1] * 1.05)), (int(bbox[2] * 0.95), int(bbox[3] * 0.95)), (255, 0, 0), cv2.FILLED) frame = cv2.addWeighted(frame, 1.0, blk, 0.5, 1) cv2.rectangle(frame, (int(bbox[0] * 1.05), int(bbox[1] * 1.05)), (int(bbox[2] * 0.95), int(bbox[3] * 0.95)), color, 2) cv2.rectangle( frame, (int(bbox[0] * 1.05), int(bbox[1] * 1.05 - 30)), (int(bbox[0] * 1.05) + (len(class_name) + len(str(track.track_id))) * 17, int(bbox[1] * 1.05)), color, -1) cv2.putText( frame, class_name + "-" + str(track.track_id), (int(bbox[0] * 1.05), int(bbox[1] * 1.05 - 10)), 0, 0.75, (255, 255, 255), 2) # if enable info flag then print details about each track if FLAGS.info: print( "Tracker ID: {}, Class: {}, BBox Coords (xmin, ymin, xmax, ymax): {}" .format(str(track.track_id), class_name, (int( bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3])))) # calculate frames per second of running detections fps = 1.0 / (time.time() - start_time) print("FPS: %.2f" % fps) avg.append(fps) print("avg fps {}".format(statistics.mean(avg))) cv2.putText(frame, "FPS: %.2f" % fps, (50, 500), cv2.FONT_HERSHEY_COMPLEX_SMALL, 2, (66, 245, 141), 2) result = np.asarray(frame) result = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) if not FLAGS.dont_show: cv2.imshow("Output Video", result) # if output flag is set, save video file if FLAGS.output: out.write(result) if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.destroyAllWindows()
def pre(): from tensorflow.compat.v1 import ConfigProto from tensorflow.compat.v1 import InteractiveSession config = ConfigProto() config.gpu_options.allow_growth = True InteractiveSession(config=config)
from numpy import save from numpy import load import pandas as pd from sklearn.model_selection import train_test_split import tensorflow as tf import pylab import matplotlib.pyplot as plt import requests import os from tensorflow.compat.v1 import ConfigProto from tensorflow.compat.v1 import InteractiveSession os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" os.environ['CUDA_VISIBLE_DEVICES'] = "0,1" #選擇哪一塊gpu config = ConfigProto() config.allow_soft_placement = True #如果你指定的設備不存在,允許TF自動分配設備 config.gpu_options.per_process_gpu_memory_fraction = 0.9 #分配百分之七十的顯存給程序使用,避免內存溢出,可以自己調整 config.gpu_options.allow_growth = True #按需分配顯存,這個比較重要 session = InteractiveSession(config=config) action_name = ["down", "up", "walk", "run", "raise"] action_name_test = [ "down_test", "up_test", "walk_test", "run_test", "raise_test" ] action_mix = ["mix"] dirname = "json_data_non_seperate" frame = 50 shift = 3 epochs = 100
def main(_argv): config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) save_trt()
def inference(preprocess_queue, inference_queue): import tensorflow as tf import core.utils as utils from tensorflow.python.saved_model import tag_constants from tensorflow.compat.v1 import InteractiveSession from tensorflow.compat.v1 import ConfigProto from core.functions import count_objects, crop_objects from core.config import cfg from core.utils import read_class_names import os import random from core.yolov4 import filter_boxes tf.keras.backend.clear_session() input_size = Parameters.input_size model = OutsourceContract.model framework = Parameters.framework tiny = OutsourceContract.tiny weights = Parameters.weights iou = Parameters.iou score = Parameters.score physical_devices = tf.config.experimental.list_physical_devices('GPU') try: if len(physical_devices) > 0: tf.config.experimental.set_memory_growth(physical_devices[0], True) except: pass # configure gpu usage config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) # load model if framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=weights) else: saved_model_loaded = tf.saved_model.load( weights, tags=[tag_constants.SERVING]) # read in all class names from config class_names = utils.read_class_names(cfg.YOLO.CLASSES) count = Parameters.count info = Parameters.info crop = Parameters.crop while True: if not preprocess_queue.empty(): queueData = preprocess_queue.get() while not preprocess_queue.empty(): queueData = preprocess_queue.get() #preprocess_queue.task_done() images_data = queueData[0] name = queueData[1] original_image = queueData[2] #preprocess_queue.task_done() if framework == 'tflite': interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() interpreter.set_tensor(input_details[0]['index'], images_data) interpreter.invoke() pred = [interpreter.get_tensor( output_details[i]['index']) for i in range(len(output_details))] if model == 'yolov3' and tiny == True: boxes, pred_conf = filter_boxes( pred[1], pred[0], score_threshold=0.25, input_shape=tf.constant([input_size, input_size])) else: boxes, pred_conf = filter_boxes( pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant([input_size, input_size])) else: infer = saved_model_loaded.signatures['serving_default'] batch_data = tf.constant(images_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections=tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=iou, score_threshold=score ) # 1.2ms # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, xmax, ymax original_h, original_w, _=original_image.shape bboxes=utils.format_boxes( boxes.numpy()[0], original_h, original_w) # 1ms #-> no tf needed # hold all detection data in one variable pred_bbox=[bboxes, scores.numpy()[0], classes.numpy()[0], valid_detections.numpy()[0]] # by default allow all classes in .names file allowed_classes=list(class_names.values()) # custom allowed classes (uncomment line below to allow detections for only people) # allowed_classes = ['person'] # if crop flag is enabled, crop each detection and save it as new image if crop: crop_path=os.path.join( os.getcwd(), 'detections', 'crop', image_name) try: os.mkdir(crop_path) except FileExistsError: pass crop_objects(cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB), pred_bbox, crop_path, allowed_classes) if count: # count objects found counted_classes=count_objects( pred_bbox, by_class=False, allowed_classes=allowed_classes) # loop through dict and print for key, value in counted_classes.items(): print("Number of {}s: {}".format(key, value)) boxtext, image=utils.draw_bbox( original_image, pred_bbox, info, counted_classes, allowed_classes=allowed_classes) else: boxtext, image=utils.draw_bbox( original_image, pred_bbox, info, allowed_classes=allowed_classes) # 0.5ms image=Image.fromarray(image.astype(np.uint8)) # 0.3ms inference_queue.put((boxtext, image, name))
def main(_argv): config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS) input_size = FLAGS.size if FLAGS.framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=FLAGS.weights) interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() print(input_details) print(output_details) else: saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] out = None # cho camera # vid = cv2.VideoCapture('rtsp://*****:*****@192.168.1.180:554/cam/realmonitor?channel=1&subtype=1') # cho webcam vid = cv2.VideoCapture(0) if FLAGS.output: # by default VideoCapture returns float instead of int width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = int(vid.get(cv2.CAP_PROP_FPS)) codec = cv2.VideoWriter_fourcc(*FLAGS.output_format) out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height)) frame_num = 0 while True: return_value, frame = vid.read() if return_value: frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) frame_num += 1 image = Image.fromarray(frame) else: print('Video has ended or failed, try a different video format!') break frame_size = frame.shape[:2] image_data = cv2.resize(frame, (input_size, input_size)) image_data = image_data / 255. image_data = image_data[np.newaxis, ...].astype(np.float32) if FLAGS.framework == 'tflite': interpreter.set_tensor(input_details[0]['index'], image_data) interpreter.invoke() pred = [ interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details)) ] if FLAGS.model == 'yolov3' and FLAGS.tiny == True: boxes, pred_conf = filter_boxes(pred[1], pred[0], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: batch_data = tf.constant(image_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=FLAGS.iou, score_threshold=FLAGS.score) # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, xmax, ymax # định dạng các hộp giới hạn từ chuẩn hóa ymin, xmin, ymax, xmax ---> xmin, ymin, xmax, ymax original_h, original_w, _ = frame.shape bboxes = utils.format_boxes(boxes.numpy()[0], original_h, original_w) pred_bbox = [ bboxes, scores.numpy()[0], classes.numpy()[0], valid_detections.numpy()[0] ] # read in all class names from config # đọc tất cả các tên lớp từ cấu hình class_names = utils.read_class_names(cfg.YOLO.CLASSES) # by default allow all classes in .names file # theo mặc định cho phép tất cả các lớp trong tệp .names allowed_classes = list(class_names.values()) # custom allowed classes (uncomment line below to allow detections for only people) # nếu muốn chọn một đối tượng riêng biệt để phát hiện # allowed_classes = ['person'] # count objects found # đếm các đối tượng được tìm thấy counted_classes = count_objects(pred_bbox, by_class=True, allowed_classes=allowed_classes) # loop through dict and print # lặp qua và in image = utils.draw_bbox(frame, pred_bbox, FLAGS.info, counted_classes, allowed_classes=allowed_classes, read_plate=FLAGS.plate) crop_rate = 200 # capture images every so many frames (ex. crop photos every 200 frames) crop_path = os.path.join(os.getcwd(), 'detections', 'crop', 'real-time2') try: os.mkdir(crop_path) except FileExistsError: pass if frame_num % crop_rate == 0: crop_objects(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), pred_bbox, crop_path, allowed_classes) else: pass result = np.asarray(image) cv2.namedWindow("result", cv2.WINDOW_AUTOSIZE) result = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) cv2.imshow("result", result) if FLAGS.output: out.write(result) if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.destroyAllWindows()
def main(_argv): config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS) input_size = FLAGS.size video_path = FLAGS.video # get video name by using split method video_name = video_path.split('/')[-1] video_name = video_name.split('.')[0] if FLAGS.framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=FLAGS.weights) interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() print(input_details) print(output_details) else: saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] # begin video capture try: vid = cv2.VideoCapture(int(video_path)) except: vid = cv2.VideoCapture(video_path) out = None if FLAGS.output: # by default VideoCapture returns float instead of int width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = int(vid.get(cv2.CAP_PROP_FPS)) codec = cv2.VideoWriter_fourcc(*FLAGS.output_format) out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height)) frame_num = 0 while True: return_value, frame_1 = vid.read() #For the tokyo picture a, b, c, d, e, f, g, h = [209, 1040], [331, 197], [1124, 197], [ 1907, 850 ], [0, 0], [1920, 0], [1920, 1080], [0, 1080] external_poly = [ np.array([e, b, c, f]), np.array([f, c, d, g]), np.array([g, d, a, h]), np.array([h, a, b, e]) ] frame = cv2.fillPoly(frame_1, external_poly, (0, 0, 0)) cv2.line(frame, (209, 1040), (331, 197), (255, 0, 0), 2) cv2.line(frame, (331, 197), (1124, 197), (255, 0, 0), 2) cv2.line(frame, (1124, 197), (1907, 850), (255, 0, 0), 2) cv2.line(frame, (209, 1040), (1907, 850), (255, 0, 0), 2) if return_value: # frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE) #rotate the video for mobile videos frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) frame_num += 1 image = Image.fromarray(frame) else: print('Video has ended or failed, try a different video format!') break if frame_num % 15 == 0: frame_size = frame.shape[:2] image_data = cv2.resize(frame, (input_size, input_size)) image_data = image_data / 255. image_data = image_data[np.newaxis, ...].astype(np.float32) start_time = time.time() if FLAGS.framework == 'tflite': interpreter.set_tensor(input_details[0]['index'], image_data) interpreter.invoke() pred = [ interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details)) ] if FLAGS.model == 'yolov3' and FLAGS.tiny == True: boxes, pred_conf = filter_boxes( pred[1], pred[0], score_threshold=0.25, input_shape=tf.constant([input_size, input_size])) else: boxes, pred_conf = filter_boxes( pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant([input_size, input_size])) else: batch_data = tf.constant(image_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=100, max_total_size=100, iou_threshold=FLAGS.iou, score_threshold=FLAGS.score) # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, xmax, ymax original_h, original_w, _ = frame.shape bboxes = utils.format_boxes(boxes.numpy()[0], original_h, original_w) pred_bbox = [ bboxes, scores.numpy()[0], classes.numpy()[0], valid_detections.numpy()[0] ] # print(pred_bbox[2]) out_boxes, out_scores, out_classes, num_boxes = pred_bbox # read in all class names from config class_names = utils.read_class_names(cfg.YOLO.CLASSES) # by default allow all classes in .names file # allowed_classes = list(class_names.values()) # custom allowed classes (uncomment line below to allow detections for only SELECTED DETECTION CLASSES) allowed_classes = ['person', 'car', 'truck', 'bus', 'motorbike'] # allowed_classes = ['car'] # if crop flag is enabled, crop each detection and save it as new image if FLAGS.crop: crop_rate = 150 # capture images every so many frames (ex. crop photos every 150 frames) crop_path = os.path.join(os.getcwd(), 'detections', 'crop', video_name) try: os.mkdir(crop_path) except FileExistsError: pass if frame_num % crop_rate == 0: final_path = os.path.join(crop_path, 'frame_' + str(frame_num)) try: os.mkdir(final_path) except FileExistsError: pass crop_objects(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), pred_bbox, final_path, allowed_classes) else: pass if FLAGS.count: # count objects found counted_classes = count_objects( pred_bbox, by_class=True, allowed_classes=allowed_classes) # loop through dict and print for key, value in counted_classes.items(): print("Number of {}s: {}".format(key, value)) image = utils.draw_bbox(frame, pred_bbox, FLAGS.info, counted_classes, allowed_classes=allowed_classes, read_plate=FLAGS.plate) else: image = utils.draw_bbox(frame, pred_bbox, FLAGS.info, allowed_classes=allowed_classes, read_plate=FLAGS.plate) fps = 1.0 / (time.time() - start_time) print("FPS: %.2f" % fps) result = np.asarray(image) cv2.namedWindow("result", cv2.WINDOW_AUTOSIZE) result = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) if not FLAGS.dont_show: cv2.imshow("result", result) if FLAGS.output: out.write(result) if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.destroyAllWindows()
def test_fw_iter(IteratorClass, args): iterator_name = IteratorClass.__module__ + "." + IteratorClass.__name__ print("Start testing {}".format(iterator_name)) sess = None daliop = None dali_train_iter = None images = [] labels = [] pipes = [ RN50Pipeline(batch_size=args.batch_size, num_threads=args.workers, device_id=n, num_gpus=args.gpus, data_paths=data_paths, prefetch=PREFETCH, fp16=args.fp16, nhwc=args.nhwc) for n in range(args.gpus) ] [pipe.build() for pipe in pipes] iters = args.iters if args.iters < 0: iters = pipes[0].epoch_size("Reader") assert (all(pipe.epoch_size("Reader") == iters for pipe in pipes)) iters_tmp = iters iters = iters // args.batch_size if iters_tmp != iters * args.batch_size: iters += 1 iters_tmp = iters iters = iters // args.gpus if iters_tmp != iters * args.gpus: iters += 1 if iterator_name == "nvidia.dali.plugin.tf.DALIIterator": daliop = IteratorClass() for dev in range(args.gpus): with tf.device('/gpu:%i' % dev): if args.fp16: out_type = tf.float16 else: out_type = tf.float32 image, label = daliop(pipeline=pipes[dev], shapes=[(args.batch_size, 3, 224, 224), ()], dtypes=[out_type, tf.int32]) images.append(image) labels.append(label) gpu_options = GPUOptions(per_process_gpu_memory_fraction=0.5) config = ConfigProto(gpu_options=gpu_options) sess = Session(config=config) end = time.time() for i in range(args.epochs): if i == 0: print("Warm up") else: print("Test run " + str(i)) data_time = AverageMeter() if iterator_name == "nvidia.dali.plugin.tf.DALIIterator": assert sess != None for j in range(iters): res = sess.run([images, labels]) data_time.update(time.time() - end) if j % args.print_freq == 0: print( "{} {}/ {}, avg time: {} [s], worst time: {} [s], speed: {} [img/s]" .format(iterator_name, j + 1, iters, data_time.avg, data_time.max_val, args.gpus * args.batch_size / data_time.avg)) end = time.time() else: dali_train_iter = IteratorClass(pipes, reader_name="Reader") j = 0 for it in iter(dali_train_iter): data_time.update(time.time() - end) if j % args.print_freq == 0: print( "{} {}/ {}, avg time: {} [s], worst time: {} [s], speed: {} [img/s]" .format(iterator_name, j + 1, iters, data_time.avg, data_time.max_val, args.gpus * args.batch_size / data_time.avg)) end = time.time() j = j + 1 if j > iters: break
import os import tensorflow as tf import numpy as np from . import SlotGatedModel from . import utils from tensorflow.compat.v1 import ConfigProto from tensorflow.compat.v1 import InteractiveSession configp = ConfigProto() configp.gpu_options.allow_growth = True session = InteractiveSession(config=configp) DATASETS_ROOT = "datasets/" MODELS_ROOT = "models/" TRAIN_FOLDER_NAME = "train" TEST_FOLDER_NAME = "test" VALID_FOLDER_NAME = "valid" TEXT_VOCAB_FILENAME = 'in_vocab' SLOTS_VOCAB_FILENAME = 'slot_vocab' INTENTS_VOCAB_FILENAME = 'intent_vocab' TEXT_FILENAME = 'seq.in' SLOTS_FILENAME = 'seq.out' INTENTS_FILENAME = 'label' CHECKPOINTS_FOLDER_NAME = "checkpoints"
def detect(input_image): config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) # load model saved_model_loaded = tf.saved_model.load('./checkpoints/yolov4-416', tags=[tag_constants.SERVING]) # loop through images in list and run Yolov4 model on each original_image = input_image original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB) image_data = cv2.resize(original_image, (input_size, input_size)) image_data = image_data / 255. image_name = 'image_input' images_data = [] for i in range(1): images_data.append(image_data) images_data = np.asarray(images_data).astype(np.float32) infer = saved_model_loaded.signatures['serving_default'] batch_data = tf.constant(images_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] # run non max suppression on detections boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=iou_threshold, score_threshold=0.50) # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, xmax, ymax original_h, original_w, _ = original_image.shape bboxes = utils.format_boxes(boxes.numpy()[0], original_h, original_w) # hold all detection data in one variable pred_bbox = [ bboxes, scores.numpy()[0], classes.numpy()[0], valid_detections.numpy()[0] ] # read in all class names from config class_names = utils.read_class_names(cfg.YOLO.CLASSES) # by default allow all classes in .names file allowed_classes = list(class_names.values()) # custom allowed classes (uncomment line below to allow detections for only people) #allowed_classes = ['person'] counted_classes = count_objects(pred_bbox, by_class=True, allowed_classes=allowed_classes) # loop through dict and print string = "" for key, value in counted_classes.items(): string = string + " " + "Number of {}s: {}".format(key, value) image = utils.draw_bbox(original_image, pred_bbox, False, counted_classes, allowed_classes=allowed_classes, read_plate=False) image = Image.fromarray(image.astype(np.uint8)) image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB) cv2.imwrite('./detections/' + 'detection' + '.png', image) return image, string
def main(_argv): # Definition of the parameters max_cosine_distance = 0.4 nn_budget = None nms_max_overlap = 1.0 # initialize deep sort model_filename = 'model_data/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename, batch_size=1) # calculate cosine distance metric metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) # initialize tracker tracker = Tracker(metric) # load configuration for object detector config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS) input_size = FLAGS.size video_path = FLAGS.video # load tflite model if flag is set if FLAGS.framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=FLAGS.weights) interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() print(input_details) print(output_details) # otherwise load standard tensorflow saved model else: saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] # begin video capture try: vid = cv2.VideoCapture(int(video_path)) except: vid = cv2.VideoCapture(video_path) out = None # get video ready to save locally if flag is set if FLAGS.output: # by default VideoCapture returns float instead of int width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = int(vid.get(cv2.CAP_PROP_FPS)) codec = cv2.VideoWriter_fourcc(*FLAGS.output_format) out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height)) # while video is running while True: return_value, frame = vid.read() if return_value: frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) image = Image.fromarray(frame) else: print('Video has ended or failed, try a different video format!') break frame_size = frame.shape[:2] image_data = cv2.resize(frame, (input_size, input_size)) image_data = image_data / 255. image_data = image_data[np.newaxis, ...].astype(np.float32) start_time = time.time() # run detections on tflite if flag is set if FLAGS.framework == 'tflite': interpreter.set_tensor(input_details[0]['index'], image_data) interpreter.invoke() pred = [interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details))] # run detections using yolov3 if flag is set if FLAGS.model == 'yolov3' and FLAGS.tiny == True: boxes, pred_conf = filter_boxes(pred[1], pred[0], score_threshold=0.25, input_shape=tf.constant([input_size, input_size])) else: boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant([input_size, input_size])) else: batch_data = tf.constant(image_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=FLAGS.iou, score_threshold=FLAGS.score ) # convert data to numpy arrays and slice out unused elements num_objects = valid_detections.numpy()[0] bboxes = boxes.numpy()[0] bboxes = bboxes[0:int(num_objects)] scores = scores.numpy()[0] scores = scores[0:int(num_objects)] classes = classes.numpy()[0] classes = classes[0:int(num_objects)] # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, width, height original_h, original_w, _ = frame.shape bboxes = utils.format_boxes(bboxes, original_h, original_w) # store all predictions in one parameter for simplicity when calling functions pred_bbox = [bboxes, scores, classes, num_objects] # read in all class names from config class_names = utils.read_class_names(cfg.YOLO.CLASSES) # by default allow all classes in .names file allowed_classes = list(class_names.values()) # custom allowed classes (uncomment line below to customize tracker for only people) #allowed_classes = ['person'] # loop through objects and use class index to get class name, allow only classes in allowed_classes list names = [] deleted_indx = [] for i in range(num_objects): class_indx = int(classes[i]) class_name = class_names[class_indx] if class_name not in allowed_classes: deleted_indx.append(i) else: names.append(class_name) names = np.array(names) # delete detections that are not in allowed_classes bboxes = np.delete(bboxes, deleted_indx, axis=0) scores = np.delete(scores, deleted_indx, axis=0) # encode yolo detections and feed to tracker features = encoder(frame, bboxes) detections = [Detection(bbox, score, class_name, feature) for bbox, score, class_name, feature in zip(bboxes, scores, names, features)] #initialize color map cmap = plt.get_cmap('tab20b') colors = [cmap(i)[:3] for i in np.linspace(0, 1, 20)] # run non-maxima supression boxs = np.array([d.tlwh for d in detections]) scores = np.array([d.confidence for d in detections]) classes = np.array([d.class_name for d in detections]) indices = preprocessing.non_max_suppression(boxs, classes, nms_max_overlap, scores) detections = [detections[i] for i in indices] # Call the tracker tracker.predict() tracker.update(detections) # update tracks for track in tracker.tracks: if not track.is_confirmed() or track.time_since_update > 1: continue bbox = track.to_tlbr() class_name = track.get_class() # draw bbox on screen color = colors[int(track.track_id) % len(colors)] color = [i * 255 for i in color] cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), color, 2) cv2.rectangle(frame, (int(bbox[0]), int(bbox[1]-30)), (int(bbox[0])+(len(class_name)+len(str(track.track_id)))*17, int(bbox[1])), color, -1) cv2.putText(frame, class_name + "-" + str(track.track_id),(int(bbox[0]), int(bbox[1]-10)),0, 0.75, (255,255,255),2) # if enable info flag then print details about each track if FLAGS.info: print("Tracker ID: {}, Class: {}, BBox Coords (xmin, ymin, xmax, ymax): {}".format(str(track.track_id), class_name, (int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3])))) # calculate frames per second of running detections fps = 1.0 / (time.time() - start_time) print("FPS: %.2f" % fps) result = np.asarray(frame) result = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) if not FLAGS.dont_show: cv2.imshow("Output Video", result) # if output flag is set, save video file if FLAGS.output: out.write(result) if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.destroyAllWindows()
# -*- coding: utf-8 -*- import pyrealsense2 as rs import numpy as np import cv2 from scipy import ndimage import matplotlib.pyplot as plt #import tensorflow as tf from tensorflow.keras.models import load_model from tensorflow.compat.v1 import ConfigProto from tensorflow.compat.v1 import InteractiveSession config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) h5_path = './result/msra_clstm_basic_120_P4.hdf5' model = load_model(h5_path) model.summary() #icvl_net = cv2.dnn.readNetFromTensorflow('./new/model.pb') height = 480 width= 640 cropHeight = 120 cropWidth = 120 fx=628.668 fy=628.668 u0=311.662 v0=231.571 xy_thres = 150 depth_thres = 120
def main(_argv): config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS) input_size = FLAGS.size image_path = FLAGS.image original_image = cv2.imread(image_path) original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB) # image_data = utils.image_preprocess(np.copy(original_image), [input_size, input_size]) image_data = cv2.resize(original_image, (input_size, input_size)) image_data = image_data / 255. # image_data = image_data[np.newaxis, ...].astype(np.float32) images_data = [] for i in range(1): images_data.append(image_data) images_data = np.asarray(images_data).astype(np.float32) if FLAGS.framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=FLAGS.weights) interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() print(input_details) print(output_details) interpreter.set_tensor(input_details[0]['index'], images_data) interpreter.invoke() pred = [interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details))] if FLAGS.model == 'yolov3' and FLAGS.tiny == True: boxes, pred_conf = filter_boxes(pred[1], pred[0], score_threshold=0.25, input_shape=tf.constant([input_size, input_size])) else: boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant([input_size, input_size])) else: saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] batch_data = tf.constant(images_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=FLAGS.iou, score_threshold=FLAGS.score ) pred_bbox = [boxes.numpy(), scores.numpy(), classes.numpy(), valid_detections.numpy()] f = open("output", "w") f.write(str(valid_detections)) f.close() image = utils.draw_bbox(original_image, pred_bbox) # image = utils.draw_bbox(image_data*255, pred_bbox) image = Image.fromarray(image.astype(np.uint8)) image.show() image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB) cv2.imwrite(FLAGS.output, image)
def main(_argv): config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS) input_size = FLAGS.size video_path = FLAGS.video if FLAGS.framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=FLAGS.weights) interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() print(input_details) print(output_details) else: saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] # begin video capture try: vid = cv2.VideoCapture(int(video_path)) except: vid = cv2.VideoCapture(video_path) out = None if FLAGS.output: # by default VideoCapture returns float instead of int width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = int(vid.get(cv2.CAP_PROP_FPS)) codec = cv2.VideoWriter_fourcc(*FLAGS.output_format) out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height)) while True: return_value, frame = vid.read() if return_value: frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) image = Image.fromarray(frame) else: print('Video has ended or failed, try a different video format!') break frame_size = frame.shape[:2] image_data = cv2.resize(frame, (input_size, input_size)) image_data = image_data / 255. image_data = image_data[np.newaxis, ...].astype(np.float32) start_time = time.time() if FLAGS.framework == 'tflite': interpreter.set_tensor(input_details[0]['index'], image_data) interpreter.invoke() pred = [ interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details)) ] if FLAGS.model == 'yolov3' and FLAGS.tiny == True: boxes, pred_conf = filter_boxes(pred[1], pred[0], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: batch_data = tf.constant(image_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=FLAGS.iou, score_threshold=FLAGS.score) pred_bbox = [ boxes.numpy(), scores.numpy(), classes.numpy(), valid_detections.numpy() ] image = utils.draw_bbox(frame, pred_bbox) fps = 1.0 / (time.time() - start_time) print("FPS: %.2f" % fps) result = np.asarray(image) cv2.namedWindow("result", cv2.WINDOW_AUTOSIZE) result = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) if not FLAGS.dont_show: cv2.imshow("result", result) if FLAGS.output: out.write(result) if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.destroyAllWindows()
from keras.backend.tensorflow_backend import set_session from tensorflow.compat.v1 import ConfigProto from tensorflow.compat.v1 import InteractiveSession, Session config = ConfigProto() config.gpu_options.allow_growth = True config.log_device_placement = True # to log device placement (on which device the operation ran) # session = InteractiveSession(config=config) import tensorflow as tf session = tf.Session(config=config) set_session(session) # set this TensorFlow session as the default session for Keras
def detector(): # Definition of the parameters max_cosine_distance = 0.4 nn_budget = None nms_max_overlap = 1.0 # initialize deep sort model_filename = 'model_data/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename, batch_size=1) # calculate cosine distance metric metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) # initialize tracker tracker = Tracker(metric) # load configuration for object detector config = ConfigProto() config.gpu_options.allow_growth = True input_size = 416 # video_path = 'data/video/vertical.mp4' video_path = 'uploads/' + session['filename'] # print(video_path) # load tflite model if flag is set # TINY saved_model_loaded = tf.saved_model.load('./checkpoints/yolov4-tiny-416', tags=[tag_constants.SERVING]) # NORMAL # saved_model_loaded = tf.saved_model.load('./checkpoints/yolov4-416', tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] # begin video capture try: vid = cv2.VideoCapture(int(video_path)) except: vid = cv2.VideoCapture(video_path) out = None # get video ready to save locally if flag is set if './outputs/output.avi': # by default VideoCapture returns float instead of int width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = int(vid.get(cv2.CAP_PROP_FPS)) codec = cv2.VideoWriter_fourcc(*'XVID') out = cv2.VideoWriter('./outputs/output.avi', codec, fps, (width, height)) frame_num = 0 # while video is running data = cv2.VideoCapture(video_path) fps = int(data.get(cv2.CAP_PROP_FPS)) print("fps: " + str(fps)) bus_counter = [] car_counter = [] truck_counter = [] sum_counter = [] myDict = {} while True: cur_minute = math.floor(frame_num / (60 * fps)) + 1 return_value, frame = vid.read() if return_value: frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) image = Image.fromarray(frame) else: print('Video has ended or failed, try a different video format!') break if fps >= 25: if frame_num % 3 != 0: frame_num += 1 continue frame_num += 1 print('Frame #: ', frame_num) print('Minute : ', cur_minute) frame_size = frame.shape[:2] image_data = cv2.resize(frame, (input_size, input_size)) image_data = image_data / 255. image_data = image_data[np.newaxis, ...].astype(np.float32) start_time = time.time() # run detections batch_data = tf.constant(image_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=0.45, score_threshold=0.50 ) # convert data to numpy arrays and slice out unused elements num_objects = valid_detections.numpy()[0] bboxes = boxes.numpy()[0] bboxes = bboxes[0:int(num_objects)] scores = scores.numpy()[0] scores = scores[0:int(num_objects)] classes = classes.numpy()[0] classes = classes[0:int(num_objects)] # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, width, height original_h, original_w, _ = frame.shape bboxes = utils.format_boxes(bboxes, original_h, original_w) # store all predictions in one parameter for simplicity when calling functions pred_bbox = [bboxes, scores, classes, num_objects] # read in all class names from config class_names = utils.read_class_names(cfg.YOLO.CLASSES) # by default allow all classes in .names file allowed_classes = list(class_names.values()) # loop through objects and use class index to get class name, allow only classes in allowed_classes list names = [] deleted_indx = [] for i in range(num_objects): class_indx = int(classes[i]) class_name = class_names[class_indx] if class_name not in allowed_classes: deleted_indx.append(i) else: names.append(class_name) names = np.array(names) count = len(names) # encode yolo detections and feed to tracker features = encoder(frame, bboxes) detections = [Detection(bbox, score, class_name, feature) for bbox, score, class_name, feature in zip(bboxes, scores, names, features)] # initialize color map cmap = plt.get_cmap('tab20b') colors = [cmap(i)[:3] for i in np.linspace(0, 1, 20)] # run non-maxima supression boxs = np.array([d.tlwh for d in detections]) scores = np.array([d.confidence for d in detections]) classes = np.array([d.class_name for d in detections]) indices = preprocessing.non_max_suppression(boxs, classes, nms_max_overlap, scores) detections = [detections[i] for i in indices] # Call the tracker tracker.predict() tracker.update(detections) # update tracks for track in tracker.tracks: if not track.is_confirmed() or track.time_since_update > 1: continue bbox = track.to_tlbr() class_name = track.get_class() # draw bbox on screen color = colors[int(track.track_id) % len(colors)] color = [i * 255 for i in color] cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), color, 2) cv2.rectangle(frame, (int(bbox[0]), int(bbox[1] - 30)), (int(bbox[0]) + (len(class_name) + len(str(track.track_id))) * 17, int(bbox[1])), color, -1) cv2.putText(frame, class_name + "-" + str(track.track_id), (int(bbox[0]), int(bbox[1] - 10)), 0, 0.75, (255, 255, 255), 2) # if enable info flag then print details about each track height, width, _ = frame.shape # Veritical cv2.line(frame, (0, int(3 * height / 6)), (width, int(3 * height / 6)), (0, 255, 0), thickness=2) center_y = int(((bbox[1]) + (bbox[3])) / 2) if center_y <= int(3 * height / 6 + height / 30) and center_y >= int(3 * height / 6 - height / 30): if class_name == 'car': car_counter.append(int(track.track_id)) sum_counter.append(int(track.track_id)) if cur_minute not in myDict: myDict[cur_minute] = [] myDict[cur_minute].append(track.track_id) elif class_name == 'truck': truck_counter.append(int(track.track_id)) sum_counter.append(int(track.track_id)) if cur_minute not in myDict: myDict[cur_minute] = [] myDict[cur_minute].append(track.track_id) elif class_name == 'bus': bus_counter.append(int(track.track_id)) sum_counter.append(int(track.track_id)) if cur_minute not in myDict: myDict[cur_minute] = [] myDict[cur_minute].append(track.track_id) # Horizontal cv2.line(frame, (int(3 * width / 6), 0), (int(3 * width / 6), height), (0, 255, 0), thickness=2) center_x = int(((bbox[0]) + (bbox[2])) / 2) if center_x <= int(3 * width / 6 + width / 30) and center_x >= int(3 * width / 6 - width / 30): if class_name == 'car': car_counter.append(int(track.track_id)) sum_counter.append(int(track.track_id)) if cur_minute not in myDict: myDict[cur_minute] = [] myDict[cur_minute].append(track.track_id) elif class_name == 'truck': truck_counter.append(int(track.track_id)) sum_counter.append(int(track.track_id)) if cur_minute not in myDict: myDict[cur_minute] = [] myDict[cur_minute].append(track.track_id) elif class_name == 'bus': bus_counter.append(int(track.track_id)) sum_counter.append(int(track.track_id)) if cur_minute not in myDict: myDict[cur_minute] = [] myDict[cur_minute].append(track.track_id) car_count = len(set(car_counter)) truck_count = len(set(truck_counter)) bus_count = len(set(bus_counter)) total_count = len(set(sum_counter)) print(total_count) cv2.putText(frame, "Total Vehicle Count: " + str(total_count), (0, 130), 0, 1, (0, 0, 255), 2) # calculate frames per second of running detections fps_running = 1.0 / (time.time() - start_time) # print("FPS: %.2f" % fps_running) result = np.asarray(frame) result = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) if './outputs/tiny.avi': out.write(result) if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.destroyAllWindows() # ======================================================================================== name_db = session['filename'] # return render_template('result.html', result=number_of_vehicles) first_sum = len(set(myDict[1])) second_sum = 0 third_sum = 0 fourth_sum = 0 fifth_sum = 0 if 2 in myDict: second_sum = len(set(myDict[2])) if 3 in myDict: third_sum = len(set(myDict[3])) if 4 in myDict: fourth_sum = len(set(myDict[4])) if 5 in myDict: fifth_sum = len(set(myDict[4])) conn = sqlite3.connect('database.db') cursor = conn.cursor() cursor.execute("INSERT INTO vehicles VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", (name_db, car_count, bus_count, truck_count, first_sum, second_sum, third_sum, fourth_sum, fifth_sum, total_count)) conn.commit() conn.close() return render_template('result.html', car=car_count, bus=bus_count, truck=truck_count, total=total_count, first=first_sum, second=second_sum, third=third_sum, fourth=fourth_sum, fifth=fifth_sum, length=cur_minute)