def learn_face(self, nb_image, user): d = Detection(self.proto, self.model) face_images = d.get_face(nb_image, 0.8) # place where images to train the recognizer on are stored path_to_images = "temp/dataset/%s" % user if not os.path.exists(path_to_images): os.makedirs(path_to_images) i = 0 for image in face_images: image_name = path_to_images + "/" + str(i) + ".jpg" i += 1 # cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) cv2.imwrite(image_name, image) ExtractEmbeddings.main(self.dataset, self.embeddings, self.proto, self.model, self.embedding_model) TrainModel.main(self.embeddings, self.recognizer, self.le) path_to_user_images = self.dataset + "/" + user shutil.rmtree(path_to_user_images) # zip output so it can be sent easily zipname = "%s_frdata.zip" % user output_zip = zipfile.ZipFile(zipname, 'w') # for folder, subfolders, files in os.walk("output"): # for file in files: # output_zip.write(os.path.join(folder, file), os.path.relpath(os.path.join(folder, file), "output"), # compress_type=zipfile.ZIP_DEFLATED) output_zip.write("output/le.pickle", "le.pickle") output_zip.write("output/recognizer.pickle", "recognizer.pickle") output_zip.close() return zipname
def get_costs_matrix(actual_blobs, detections, threshold): # the costs matrix width has to be larger or equal than height rows_count = len(actual_blobs) if rows_count > len(detections): columns_count = rows_count for i in range(0, len(actual_blobs) - len(detections)): detections = np.append(detections, Detection()) else: columns_count = len(detections) costs_matrix = np.zeros(shape=(rows_count, columns_count), dtype=float) for i, blob in enumerate(actual_blobs): for j, detection in enumerate(detections): if detection.position is None: costs_matrix[i][j] = INFINITE else: distance = euclidean_distance( blob_center(blob), blob_center(detection.position) ) costs_matrix[i][j] = \ distance if distance <= threshold else INFINITE return costs_matrix, detections
def update(self, bbox_xcycwh, confidences, ori_img,update_fg=True): self.height, self.width = ori_img.shape[:2] # generate detections if update_fg or not(len(bbox_xcycwh)==len(self.feature_tmp)): features = self._get_features(bbox_xcycwh, ori_img) self.feature_tmp = features else: features = self.feature_tmp detections = [Detection(bbox_xcycwh[i], conf, features[i]) for i,conf in enumerate(confidences) if conf>self.min_confidence] # run on non-maximum supression # boxes = np.array([d.tlwh for d in detections]) # scores = np.array([d.confidence for d in detections]) # indices = non_max_suppression( boxes, self.nms_max_overlap, scores) # detections = [detections[i] for i in indices] # update tracker self.tracker.predict() self.tracker.update(detections) # output bbox identities outputs = [] for track in self.tracker.tracks: #print('time_s',track.time_since_update) if not track.is_confirmed() or track.time_since_update > 1: continue box = track.to_tlwh() x1,y1,x2,y2 = self._tlwh_to_xyxy(box) track_id = track.track_id fg = self.check_in_out(track) outputs.append(np.array([x1,y1,x2,y2,track_id,fg], dtype=np.int)) if len(outputs) > 0: outputs = np.stack(outputs,axis=0) return outputs
def end_ship_event(self): time.sleep(0.05) tempDetection = Detection(self.args) tempDetection.serialId, tempDetection.x, tempDetection.y = 0, [], [] self.fire_and_forget() if not self.args["TEST"]: string_to_send = """ mutation{ endShipEvent(eventId: %d ){ id, } } """ % (self.id) request = requests.post(self.args["URL"], json={'query': string_to_send}) if self.args["INFO"]: print( f"close event {self.id} type {self.eventType} in camera {self.cameraId} in time {datetime.datetime.now()}" ) if request.status_code != 200 and self.args["ERRORS"]: if self.args["WARNINGS"]: logging.warning( f"Query failed to run by returning code of {request.status_code} in end_ship_event" ) else: if self.args["INFO"]: print( f"close event {self.id} type {self.eventType} in camera {self.cameraId} in time {datetime.datetime.now()}" ) self.open = False self.published = False self.closedTime = time.time()
def main(): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(('localhost', 51000)) detecter = Detection() dp = Display() ad = Audio() thread = Thread(target=dp.start) thread.setDaemon(True) thread.start() state_before = 0 while True: motor_power, target_dist = detecter.detect() # 走行プログラムと送信 sock.sendall(motor_power.to_bytes(2, 'big') + target_dist.to_bytes(2, 'big')) byte_data = sock.recv(4) #print(byte_data) state = int.from_bytes(byte_data[:2], 'big') ad_flag = int.from_bytes(byte_data[2:], 'big') #print(state) if state != state_before: dp.changeImage(state) if ad_flag == 1: if state_before == 0: ad.play(0) elif state == 5: ad.play(1) elif state_before == 5: ad.play(2) state_before = state
def __init__(self): self.c = Communicate() self.d = Detection() self.m = Measure() self.msg_list = MSG_LIST # 提示消息字典 self.cmd_dict = {} # 命令字典 self._func_dict() # 填充cmd_dict,将类方法名中后缀为'_(\d+)'的方法添加进命令字典
def test_metrics_bad_confidence(self): # [2 2 10 20; 80 80 30 40] true1 = BoundingBox(1, 'A', (2, 2), (12, 22)) true2 = BoundingBox(1, 'A', (80, 80), (110, 120)) labels = [true1, true2] # [4 4 10 20; 50 50 30 10; 90 90 40 50]; pred1 = BoundingBox(1, 'A', (4, 4), (14, 24), confidence=0.1) pred2 = BoundingBox(1, 'A', (50, 50), (80, 60), confidence=0.1) pred3 = BoundingBox(1, 'A', (80, 80), (110, 120), confidence=0.1) predictions = [pred1, pred2, pred3] det = Detection(labels=labels, predictions=predictions) pr, re, _ = det.metrics() self.assertEqual(pr, 0.0) self.assertEqual(re, 0.0) pr, re, _ = det.metrics(confidence_threshold=0.1) self.assertEqual(pr, 2.0 / 3.0) self.assertEqual(re, 1.000)
def get_objects(self, frame): """Converts bytes into Detection objects. Arguments: frame {Bytes} -- Raw data to parse Returns: [Detection], int -- list of Detections, frame taken time """ time = int.from_bytes(frame[0:4], byteorder='little') size = len(frame) detected_objects = [] for i in range(int(size/(5*4))): start_idx = 4 + 24 * i class_id = int.from_bytes( frame[start_idx:start_idx+4], byteorder='little') x = int.from_bytes( frame[start_idx+4:start_idx+7], byteorder='little') y = int.from_bytes( frame[start_idx+8:start_idx+11], byteorder='little') w = int.from_bytes( frame[start_idx+12:start_idx+15], byteorder='little') h = int.from_bytes( frame[start_idx+16:start_idx+19], byteorder='little') frame_id = int.from_bytes( frame[start_idx+20:start_idx+23], byteorder='little') class_name = self._dict.id_to_class_name(class_id) new_obj = Detection(x, y, w, h, time, frame_id, \ class_name=class_name, class_id=class_id) detected_objects.append(new_obj) return detected_objects, time
def main(): img = parseInput() d = Detection() link_coord = d.run(img) laser_coord = getLaserCoords(img) print("Link Coordinates", link_coord) print("Laser Coordinates", laser_coord)
def __init__(self): self.webcam = Webcam() self.webcam.start() self.detection = Detection() self.x_axis = 0.0 self.y_axis = 0.0 self.z_axis = 0.0 self.z_pos = -7.0
def __init__(self, text_to_speech, speech_to_text): Feature.__init__(self) Speaking.__init__(self, text_to_speech) Emotion.__init__(self) self.speech_to_text = speech_to_text self.background_image = np.array([]) self.detection_image = np.array([]) self.detection = Detection() self.reels = [None, None, None] self.holds = [None, None] self.coins = 100
def __init__(self): # self.state = 'start' self.state = 'intent' self.exit = False self.curr_msg = None self.menu = {} self.create_menu_graph() self.browser = 'chrome' # print(self.menu) self.spell_check_model = SpellCorrectionModel(language='en') self.domain_spell_check_model = SpellCorrectionModel(language='en') self.spell_check_model.load('en.pkl') self.domain_spell_check_model.load('custom_model.pkl') with open('data.json', "r") as f: self.db = json.load(f) f.close() # with open('words.json') as f: # self.all_words = json.load(f) # f.close() pk_file = open('final.pkl', 'rb') answers = pickle.load(pk_file) self.answer_detector = Detection(answers=answers, detection_type='answer') intent_answers = [] for each in INTENT_DATA: for i in INTENT_DATA[each]['data']: intent_answers.append( (clean_text(i), INTENT_DATA[each]['number'])) self.intent_detector = Detection(answers=intent_answers, detection_type='intent') port = 465 # For SSL smtp_server = "smtp.gmail.com" self.sender_email = "*****@*****.**" self.receiver_email = "*****@*****.**" password = "******" context = ssl.create_default_context() self.server = smtplib.SMTP_SSL(smtp_server, port, context=context) self.server.login(self.sender_email, password)
def convert_detections(detections, features, appearance_features, detections_3d): detection_list = [] if detections_3d is None: detections_3d = [None] * len(detections) for detection, feature, appearance_feature, detection_3d in zip( detections, features, appearance_features, detections_3d): x1, y1, x2, y2, conf, _, _ = detection box_2d = [x1, y1, x2 - x1, y2 - y1] if detection_3d is not None: x, y, z, l, w, h, theta = detection_3d box_3d = [x, y, z, l, w, h, theta] else: box_3d = None if feature is None: detection_list.append( Detection(box_2d, None, conf, appearance_feature, feature)) else: detection_list.append( Detection(box_2d, box_3d, conf, appearance_feature, feature)) return detection_list
def detect(self, image, return_image=False): data = [] if self.detector == None: ids, corners, centers, Hs = pyAprilTag.find(image) for i in range(len(ids)): # reversing corners since that's the order they were in for the older library corners_list = corners[i].tolist() corners_list.reverse() data.append( Detection(ids[i], centers[i], corners_list, util.compute_angle(corners_list))) else: data = [ Detection(detection.tag_id, detection.center, detection.corners, util.compute_angle(detection.corners)) for detection in self.detector.detect(image, False) ] data.sort(key=lambda entry: entry.tag_id) if return_image: return data, image else: return data
def main(): # Define class detection = Detection() user_interface = UserInterface() # Define var layout_crowd_detection = user_interface.layout_crowd_detection() layout_define_threshold = user_interface.layout_define_threshold() # Define threshold threshold = define_threshold(layout_define_threshold) # Crowd detection if not threshold == 'exit': detection.crowd_detection(threshold, layout_crowd_detection) print("Exit system")
def detections_from_csv(csv_filepath: str) -> List[Detection]: """ reads a detection list from csv file :param csv_filepath: csv file path :return: detections list """ detections = list() with open(csv_filepath, newline='') as csvfile: reader = csv.DictReader(csvfile) for row in reader: top_right_coord = Coordinate(int(row[X_TOP_RIGHT_KEY]), int(row[Y_TOP_RIGHT_KEY])) bb = BoundingBox(top_right_coord, int(row[BB_W]), int(row[BB_H])) detection = Detection(bb, float(row[SCORE])) detections.append(detection) return detections
def predicted_position_as_real(self, time): """When no coordinates has been linked appends predicted position to history. Arguments: time {int} -- image download time """ previous_box = self._boxes_history[-1] prediced_state = self._filter.x time = time % 0xffffffff box = Detection(prediced_state[0], prediced_state[2], int(prediced_state[4]), int(prediced_state[5]), time, previous_box.frame_id + 1, \ class_name=self._class_name) self._boxes_history.append(box) self.time_since_update += 1
def run(self): detect = Detection( graph=PATH_TO_GRAPH, labels=PATH_TO_LABELS, classes=NUM_CLASSES ) try: while True: connection, addr = self.socket.accept() client_thread = threading.Thread( target=self.process, args=(connection, detect) ) # 有新的连接建立时,创建新线程 client_thread.start() except: detect.terminate() print('Exceptions Occurred !')
def runCAMprocess(): d = Detection() while True: img_str = "" while True: data = camera_conn.recv(1024) img_str += data if "breakbreakbreak" in str(data): break print("Received Image") received_file = 'received_image.jpg' resized_file = 'resized_image.jpg' decoded_img = base64.b64decode( img_str.replace("breakbreakbreak", "") + "===") with open(received_file, 'wb') as f: f.write(decoded_img) img = cv2.imread(received_file) #resize_img = cv2.resize(img, (1280, 960)) resize_img = cv2.resize(img, (960, 720)) cv2.imwrite(resized_file, resize_img) b64_str = "" with open(resized_file, "rb") as imageFile: b64_str = base64.b64encode(imageFile.read()) b64_str = b64_str + "breakbreakbreak" num_chunks = len(b64_str) / 1024 for i in range(0, num_chunks - 1): web_conn.send(b64_str[1024 * i:1024 * (i + 1)]) web_conn.send(b64_str[1024 * (num_chunks - 1):]) print("Sent Image to Dashboard") location_data1, location_data2 = getLocations(d, img) controls_conn.send("clean" + location_data1) print(location_data1) camera_conn.send(location_data1) web_conn.send(location_data2) print("Sent Position Data to Pi 3 and Dashboard") print(" ")
def get_box_from_object_detection(yolo, image): (h, w) = image.shape[:2] center_point = (int(w / 2), int(h / 2)) final_detections = [] image = Image.fromarray(image[..., ::-1]) # bgr to rgb boxes, confidence, classes = yolo.detect_image(image) detections = [ Detection(bbox, confidence, cls) for bbox, confidence, cls in zip(boxes, confidence, classes) ] # Run non-maxima suppression. boxes = np.array([d.tlwh for d in detections]) scores = np.array([d.confidence for d in detections]) classes = np.array([d.cls for d in detections]) indices = non_max_suppression(boxes, 1.0, scores) detections = [detections[i] for i in indices] # cv2.imshow("Bounding Box", cv2.resize(after_registration_object, (800, 500))) # cv2.waitKey(1) if len(detections) == 0: print("No human object detection!") return None for detection in detections: start_x, _, end_x, _ = detection.to_tlbr() # Registration only on the center area of image if end_x < center_point[0] or start_x > center_point[0]: continue final_detections.append(detection) # get biggest bounding boxes (closest object) if len(final_detections) >= 1: final_detections = sorted(final_detections, key=sort_by_bb_area, reverse=True) else: return None return final_detections[0].tlwh
def load_detections(dataset, detector, boat_class, min_conf): text_file_path = "detections_no_desc/%s/%s.txt" % (dataset, detector) f = open(text_file_path, "r") line = f.readline() detections = {} comps = [] while (line): line = line.replace("\n", "") comps = line.split(",") if (int(comps[2]) == boat_class and float(comps[3]) > min_conf): if (not comps[0] in detections): detections[comps[0]] = [] if (not (int(comps[4]) > 270 and int(comps[4]) < 740 and int(comps[5]) > 540 and int(comps[6]) > 580)): detections[comps[0]].append( Detection(comps[3], comps[4:8], comps[8:])) line = f.readline() f.close() detections_after = {} for k in detections.keys(): cur = detections[k] detections_after[k] = [] #print('there was ',len(cur),' detections') for item in cur: contained = False for item2 in cur: overlap = get_overlap_to_self(item, item2) if (overlap > 0.5): #print('overlap is ',overlap,' discarding...') contained = True break if (contained == False): detections_after[k].append(item.copy()) #print('now there are ', len(detections_after[k]),' detections') return detections_after
def test_precision_bad_predicts_stream(self): det = Detection() det.add_label(BoundingBox(1, 'A', (2, 2), (12, 22))) det.add_label(1, 'A', 80, 80, 110, 120) det.add_label(BoundingBox(1, 'A', (20, 20), (30, 30))) # [4 4 10 20; 50 50 30 10; 90 90 40 50]; pred1 = BoundingBox(1, 'A', (4, 4), (14, 24)) pred2 = BoundingBox(1, 'A', (50, 50), (80, 60)) pred3 = BoundingBox(1, 'B', (80, 80), (110, 120)) det.add_prediction(BoundingBox(1, 'A', (4, 4), (14, 24))) det.add_prediction(1, 'A', 50, 50, 80, 60) det.add_prediction(1, 'B', 80, 80, 110, 120) pr, re, _ = det.metrics() self.assertEqual(pr, 1.0 / 3.0) self.assertEqual(re, 1.0 / 3.0)
def test_precision_one_class(self): # [2 2 10 20; 80 80 30 40] true1 = BoundingBox(1, 'A', (2, 2), (12, 22)) true2 = BoundingBox(1, 'A', (80, 80), (110, 120)) labels = [true1, true2] # [4 4 10 20; 50 50 30 10; 90 90 40 50]; pred1 = BoundingBox(1, 'A', (4, 4), (14, 24)) pred2 = BoundingBox(1, 'A', (50, 50), (80, 60)) pred3 = BoundingBox(1, 'A', (80, 80), (110, 120)) predictions = [pred1, pred2, pred3] det = Detection(labels=labels, predictions=predictions) pr, re, _ = det.metrics() self.assertEqual(pr, 2.0 / 3.0) self.assertEqual(re, 1.000)
def __init__(self): super(MainGUI, self).__init__() self.initiate_shared_variables() # Create detection and load model self.detection = Detection(shared_variables=self.shared_variables) self.threadpool = QThreadPool() print("Multithreading with maximum %d threads" % self.threadpool.maxThreadCount()) """ self.timer = QTimer() self.timer.setInterval(10) self.timer.timeout.connect(self.print_output) self.timer.start() """ # Start Detection thread self.start_worker()
def convert_single(self, detected_object, frame_millis): """Converts single DetectedObject object into Detection. Arguments: detected_object {DetectedObject} -- Object to convert. frame_millis {int} -- Analyzed picture taken time. Returns: Detection -- Target object. """ frame_millis = frame_millis % 0xffffffff return Detection( \ detected_object.x, \ detected_object.y, \ detected_object.w, \ detected_object.h, \ frame_millis, \ detected_object.frame_id, \ class_name=detected_object.class_name, \ class_id = detected_object.class_id)
def setup(): global camera_conn, camera_addr, controls_conn, controls_addr, web_conn, web_addr camera_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) controls_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) web_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) print('Sockets created.') camera_socket.bind((HOST, CAMERA_PORT)) controls_socket.bind((HOST, CONTROLS_PORT)) web_socket.bind((HOST, WEB_PORT)) print('Socket binds complete.') camera_socket.listen(10) controls_socket.listen(10) web_socket.listen(10) print('Sockets now listening.') camera_conn, camera_addr = camera_socket.accept() controls_conn, controls_addr = controls_socket.accept() web_conn, web_addr = web_socket.accept() d = Detection()
from imutils.video import FPS import numpy as np import argparse import imutils import cv2 from detection import Detection sign_detect = Detection() stream = cv2.VideoCapture(0) fps = FPS().start() while True: (grabbed, frame) = stream.read() if not grabbed: break sign_detect.signDetected(frame) cv2.imshow("Frame", frame) if cv2.waitKey(10) == 27: break fps.update() fps.stop() stream.release() cv2.destroyAllWindows()
def create_network(self, net_info, input_width=None, input_height=None, input_channels=None): models = OrderedDict() blob_channels = dict() blob_width = dict() blob_height = dict() layers = net_info['layers'] props = net_info['props'] layer_num = len(layers) blob_channels['data'] = 3 if input_channels != None: blob_channels['data'] = input_channels blob_height['data'] = 1 if input_height != None: blob_height['data'] = input_height blob_width['data'] = 1 if input_width != None: blob_width['data'] = input_width if props.has_key('input_shape'): blob_channels['data'] = int(props['input_shape']['dim'][1]) blob_height['data'] = int(props['input_shape']['dim'][2]) blob_width['data'] = int(props['input_shape']['dim'][3]) self.width = int(props['input_shape']['dim'][3]) self.height = int(props['input_shape']['dim'][2]) elif props.has_key('input_dim'): blob_channels['data'] = int(props['input_dim'][1]) blob_height['data'] = int(props['input_dim'][2]) blob_width['data'] = int(props['input_dim'][3]) self.width = int(props['input_dim'][3]) self.height = int(props['input_dim'][2]) if input_width != None and input_height != None: blob_width['data'] = input_width blob_height['data'] = input_height self.width = input_width self.height = input_height i = 0 while i < layer_num: layer = layers[i] lname = layer['name'] if layer.has_key('include') and layer['include'].has_key('phase'): phase = layer['include']['phase'] lname = lname + '.' + phase ltype = layer['type'] tname = layer['top'] if ltype in ['Data', 'AnnotatedData']: if not self.omit_data_layer: models[lname] = CaffeData(layer.copy()) data, label = models[lname].forward() data_name = tname[0] if type(tname) == list else tname blob_channels[data_name] = data.size( 1) # len(layer['transform_param']['mean_value']) blob_height[data_name] = data.size( 2 ) #int(layer['transform_param']['resize_param']['height']) blob_width[data_name] = data.size( 3 ) #int(layer['transform_param']['resize_param']['width']) self.height = blob_height[data_name] self.width = blob_width[data_name] i = i + 1 continue bname = layer['bottom'] if ltype == 'Convolution': convolution_param = layer['convolution_param'] channels = blob_channels[bname] out_filters = int(convolution_param['num_output']) kernel_size = int(convolution_param['kernel_size']) stride = int(convolution_param['stride'] ) if convolution_param.has_key('stride') else 1 pad = int(convolution_param['pad'] ) if convolution_param.has_key('pad') else 0 group = int(convolution_param['group'] ) if convolution_param.has_key('group') else 1 dilation = 1 if convolution_param.has_key('dilation'): dilation = int(convolution_param['dilation']) bias = True if convolution_param.has_key( 'bias_term' ) and convolution_param['bias_term'] == 'false': bias = False models[lname] = nn.Conv2d(channels, out_filters, kernel_size=kernel_size, stride=stride, padding=pad, dilation=dilation, groups=group, bias=bias) blob_channels[tname] = out_filters blob_width[tname] = (blob_width[bname] + 2 * pad - kernel_size) / stride + 1 blob_height[tname] = (blob_height[bname] + 2 * pad - kernel_size) / stride + 1 i = i + 1 elif ltype == 'BatchNorm': momentum = 0.9 if layer.has_key('batch_norm_param') and layer[ 'batch_norm_param'].has_key('moving_average_fraction'): momentum = float( layer['batch_norm_param']['moving_average_fraction']) channels = blob_channels[bname] models[lname] = nn.BatchNorm2d(channels, momentum=momentum, affine=False) blob_channels[tname] = channels blob_width[tname] = blob_width[bname] blob_height[tname] = blob_height[bname] i = i + 1 elif ltype == 'Scale': channels = blob_channels[bname] models[lname] = Scale(channels) blob_channels[tname] = channels blob_width[tname] = blob_width[bname] blob_height[tname] = blob_height[bname] i = i + 1 elif ltype == 'ReLU': inplace = (bname == tname) if layer.has_key('relu_param') and layer['relu_param'].has_key( 'negative_slope'): negative_slope = float( layer['relu_param']['negative_slope']) models[lname] = nn.LeakyReLU(negative_slope=negative_slope, inplace=inplace) else: models[lname] = nn.ReLU(inplace=inplace) blob_channels[tname] = blob_channels[bname] blob_width[tname] = blob_width[bname] blob_height[tname] = blob_height[bname] i = i + 1 elif ltype == 'Pooling': kernel_size = int(layer['pooling_param']['kernel_size']) stride = int(layer['pooling_param']['stride']) padding = 0 if layer['pooling_param'].has_key('pad'): padding = int(layer['pooling_param']['pad']) pool_type = layer['pooling_param']['pool'] if pool_type == 'MAX': models[lname] = nn.MaxPool2d(kernel_size, stride, padding=padding, ceil_mode=True) elif pool_type == 'AVE': models[lname] = nn.AvgPool2d(kernel_size, stride, padding=padding, ceil_mode=True) blob_width[tname] = int( math.ceil((blob_width[bname] + 2 * padding - kernel_size) / float(stride))) + 1 blob_height[tname] = int( math.ceil( (blob_height[bname] + 2 * padding - kernel_size) / float(stride))) + 1 blob_channels[tname] = blob_channels[bname] i = i + 1 elif ltype == 'Eltwise': operation = 'SUM' if layer.has_key('eltwise_param') and layer[ 'eltwise_param'].has_key('operation'): operation = layer['eltwise_param']['operation'] bname0 = bname[0] bname1 = bname[1] models[lname] = Eltwise(operation) blob_channels[tname] = blob_channels[bname0] blob_width[tname] = blob_width[bname0] blob_height[tname] = blob_height[bname0] i = i + 1 elif ltype == 'InnerProduct': filters = int(layer['inner_product_param']['num_output']) if blob_width[bname] != -1 or blob_height[bname] != -1: channels = blob_channels[bname] * blob_width[ bname] * blob_height[bname] models[lname] = nn.Sequential(FCView(), nn.Linear(channels, filters)) else: channels = blob_channels[bname] models[lname] = nn.Linear(channels, filters) blob_channels[tname] = filters blob_width[tname] = 1 blob_height[tname] = 1 i = i + 1 elif ltype == 'Dropout': channels = blob_channels[bname] dropout_ratio = float(layer['dropout_param']['dropout_ratio']) models[lname] = nn.Dropout(dropout_ratio, inplace=True) blob_channels[tname] = blob_channels[bname] blob_width[tname] = blob_width[bname] blob_height[tname] = blob_height[bname] i = i + 1 elif ltype == 'Normalize': channels = blob_channels[bname] scale = float(layer['norm_param']['scale_filler']['value']) models[lname] = Normalize(channels, scale) blob_channels[tname] = blob_channels[bname] blob_width[tname] = blob_width[bname] blob_height[tname] = blob_height[bname] i = i + 1 elif ltype == 'LRN': local_size = int(layer['lrn_param']['local_size']) alpha = float(layer['lrn_param']['alpha']) beta = float(layer['lrn_param']['beta']) models[lname] = LRN(local_size, alpha, beta) blob_channels[tname] = blob_channels[bname] blob_width[tname] = blob_width[bname] blob_height[tname] = blob_height[bname] i = i + 1 elif ltype == 'Permute': orders = layer['permute_param']['order'] order0 = int(orders[0]) order1 = int(orders[1]) order2 = int(orders[2]) order3 = int(orders[3]) models[lname] = Permute(order0, order1, order2, order3) shape = [ 1, blob_channels[bname], blob_height[bname], blob_width[bname] ] blob_channels[tname] = shape[order1] blob_height[tname] = shape[order2] blob_width[tname] = shape[order3] i = i + 1 elif ltype == 'Flatten': axis = int(layer['flatten_param']['axis']) models[lname] = Flatten(axis) blob_channels[tname] = blob_channels[bname] * blob_width[ bname] * blob_height[bname] blob_width[tname] = 1 blob_height[tname] = 1 i = i + 1 elif ltype == 'Slice': axis = int(layer['slice_param']['axis']) assert (axis == 1) assert (type(tname) == list) slice_points = layer['slice_param']['slice_point'] assert (type(slice_points) == list) assert (len(slice_points) == len(tname) - 1) slice_points = [int(s) for s in slice_points] shape = [ 1, blob_channels[bname], blob_height[bname], blob_width[bname] ] slice_points.append(shape[axis]) models[lname] = Slice(axis, slice_points) prev = 0 for idx, tn in enumerate(tname): blob_channels[tn] = slice_points[idx] - prev blob_width[tn] = blob_width[bname] blob_height[tn] = blob_height[bname] prev = slice_points[idx] i = i + 1 elif ltype == 'Concat': axis = 1 if layer.has_key('concat_param' ) and layer['concat_param'].has_key('axis'): axis = int(layer['concat_param']['axis']) models[lname] = Concat(axis) if axis == 1: blob_channels[tname] = 0 for bn in bname: blob_channels[tname] += blob_channels[bn] blob_width[tname] = blob_width[bn] blob_height[tname] = blob_height[bn] elif axis == 2: blob_channels[tname] = blob_channels[bname[0]] blob_width[tname] = 1 blob_height[tname] = 0 for bn in bname: blob_height[tname] += blob_height[bn] i = i + 1 elif ltype == 'PriorBox': min_size = float(layer['prior_box_param']['min_size']) max_size = -1 if layer['prior_box_param'].has_key('max_size'): max_size = float(layer['prior_box_param']['max_size']) aspects = [] if layer['prior_box_param'].has_key('aspect_ratio'): print(layer['prior_box_param']['aspect_ratio']) aspects = layer['prior_box_param']['aspect_ratio'] aspects = [float(aspect) for aspect in aspects] clip = (layer['prior_box_param']['clip'] == 'true') flip = False if layer['prior_box_param'].has_key('flip'): flip = (layer['prior_box_param']['flip'] == 'true') step = int(layer['prior_box_param']['step']) offset = float(layer['prior_box_param']['offset']) variances = layer['prior_box_param']['variance'] variances = [float(v) for v in variances] models[lname] = PriorBox(min_size, max_size, aspects, clip, flip, step, offset, variances) blob_channels[tname] = 1 blob_width[tname] = 1 blob_height[tname] = 1 i = i + 1 elif ltype == 'DetectionOutput': num_classes = int( layer['detection_output_param']['num_classes']) bkg_label = int( layer['detection_output_param']['background_label_id']) top_k = int( layer['detection_output_param']['nms_param']['top_k']) keep_top_k = int(layer['detection_output_param']['keep_top_k']) conf_thresh = float( layer['detection_output_param']['confidence_threshold']) nms_thresh = float(layer['detection_output_param']['nms_param'] ['nms_threshold']) models[lname] = Detection(num_classes, bkg_label, top_k, conf_thresh, nms_thresh, keep_top_k) blob_channels[tname] = 1 blob_width[tname] = 1 blob_height[tname] = 1 i = i + 1 elif ltype == 'MultiBoxLoss': num_classes = int(layer['multibox_loss_param']['num_classes']) overlap_threshold = float( layer['multibox_loss_param']['overlap_threshold']) prior_for_matching = layer['multibox_loss_param'][ 'use_prior_for_matching'] == 'true' bkg_label = int( layer['multibox_loss_param']['background_label_id']) neg_mining = True neg_pos = float(layer['multibox_loss_param']['neg_pos_ratio']) neg_overlap = float( layer['multibox_loss_param']['neg_overlap']) models[lname] = MultiBoxLoss(num_classes, overlap_threshold, prior_for_matching, bkg_label, neg_mining, neg_pos, neg_overlap, use_gpu=True) blob_channels[tname] = 1 blob_width[tname] = 1 blob_height[tname] = 1 i = i + 1 elif ltype == 'Crop': axis = int(layer['crop_param']['axis']) offset = int(layer['crop_param']['offset']) models[lname] = Crop(axis, offset) blob_channels[tname] = blob_channels[bname[0]] blob_width[tname] = blob_width[bname[0]] blob_height[tname] = blob_height[bname[0]] i = i + 1 elif ltype == 'Deconvolution': #models[lname] = nn.UpsamplingBilinear2d(scale_factor=2) #models[lname] = nn.Upsample(scale_factor=2, mode='bilinear') in_channels = blob_channels[bname] out_channels = int(layer['convolution_param']['num_output']) group = int(layer['convolution_param']['group']) kernel_w = int(layer['convolution_param']['kernel_w']) kernel_h = int(layer['convolution_param']['kernel_h']) stride_w = int(layer['convolution_param']['stride_w']) stride_h = int(layer['convolution_param']['stride_h']) pad_w = int(layer['convolution_param']['pad_w']) pad_h = int(layer['convolution_param']['pad_h']) kernel_size = (kernel_h, kernel_w) stride = (stride_h, stride_w) padding = (pad_h, pad_w) bias_term = layer['convolution_param']['bias_term'] != 'false' models[lname] = nn.ConvTranspose2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, groups=group, bias=bias_term) blob_channels[tname] = out_channels blob_width[tname] = 2 * blob_width[bname] blob_height[tname] = 2 * blob_height[bname] i = i + 1 elif ltype == 'Reshape': reshape_dims = layer['reshape_param']['shape']['dim'] reshape_dims = [int(item) for item in reshape_dims] models[lname] = Reshape(reshape_dims) blob_channels[tname] = 1 blob_width[tname] = 1 blob_height[tname] = 1 i = i + 1 elif ltype == 'Softmax': axis = 1 if layer.has_key('softmax_param' ) and layer['softmax_param'].has_key('axis'): axis = int(layer['softmax_param']['axis']) models[lname] = Softmax(axis) blob_channels[tname] = blob_channels[bname] blob_width[tname] = 1 blob_height[tname] = 1 i = i + 1 elif ltype == 'Accuracy': models[lname] = Accuracy() blob_channels[tname] = 1 blob_width[tname] = 1 blob_height[tname] = 1 i = i + 1 elif ltype == 'SoftmaxWithLoss': models[lname] = SoftmaxWithLoss() blob_channels[tname] = 1 blob_width[tname] = 1 blob_height[tname] = 1 i = i + 1 else: print('create_network: unknown type #%s#' % ltype) i = i + 1 input_width = blob_width[bname] if type( bname) != list else blob_width[bname[0]] input_height = blob_height[bname] if type( bname) != list else blob_height[bname[0]] input_channels = blob_channels[bname] if type( bname) != list else blob_channels[bname[0]] output_width = blob_width[tname] if type( tname) != list else blob_width[tname[0]] output_height = blob_height[tname] if type( tname) != list else blob_height[tname[0]] output_channels = blob_channels[tname] if type( tname) != list else blob_channels[tname[0]] print('create %-20s (%4d x %4d x %4d) -> (%4d x %4d x %4d)' % (lname, input_channels, input_height, input_width, output_channels, output_height, output_width)) return models
IOU_THRESHOLD = config["EVAL"]['IOU_THRESHOLD'] # DETECTION PARAMETERS lasot_dir = lasot_dir + "/*/" folders = glob.glob(lasot_dir) # print(folders[0].split('\\')[-2]) tracker = Tracking( config='tracking/experiments/siamrpn_r50_l234_dwxcorr/config.yaml', snapshot='tracking/experiments/siamrpn_r50_l234_dwxcorr/model.pth') detector = Detection( config="./detectron2/configs/COCO-InstanceSegmentation/small.yaml", model= "detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl" ) reid_module = REID(model=REID_BACKBONE) tracklet = Tracklet(TRACKLET_SIZE) running_stats = RunningStats() def reid_rescore(reid_module, frame, template_features, bboxes, scores): # rescore detection and tracking results with REID module and sort results. batch = [] for bbox in bboxes:
# Calculate real-world measurements real_x, real_y = detector_state.find_blob_distance(x, y) real_size = detector_state.find_blob_size(size, real_y) # Calculate the area of holes in the contour #contour_hole_area = sum([cv2.contourArea(cont) # for j, cont in enumerate(contours) #if hierarchy[0][j][3] == i]) contour_hole_area = None blobs.append( Blob(x, y, contour, contour_hole_area, size, area, real_x, real_y, real_size)) detection = Detection(blobs) # Run Filter Heuristics heuristic_total = heuristics.get_weighted_result(detection, detector_state) # Distill heuristics into a detection # detection.chosen_blob = chosen for heuristic_weight, blob in zip(heuristic_total, detection): if heuristic_weight >= heuristics.threshold: detection.chosen_blobs.append(blob) # Check Failure Cases for failure_case in failure_cases: must_fail = failure_case.test(detection, detector_state) if must_fail: failure_text = failure_case.get_failure_text()