changed objs_found structure

app/api/routes.py

@@ -176,9 +176,8 @@ def get_crops(username):
     image=np.array(image)
     print(image.shape)
 
-    _,objs_found=face_detector.predict(image)
+    objs_found=face_detector.predict(image)
     # print(objs_found)
-    objs_found=face_detector.square_preprocessing.rescale(objs_found)   #rescale coordinates to original image's resolution
       
     all_aligned_crops=fd_get_crops(image,objs_found,aligner_obj,resize=(face_recognizer.model_config.input_size,face_recognizer.model_config.input_size))
     all_aligned_crops_base64=[]
@@ -225,8 +224,7 @@ def face_recognition(username):
         print(faces[i],":",db_faces_features[i].shape)
     
     
-    _,objs_found=face_detector.predict(image)
-    objs_found=face_detector.square_preprocessing.rescale(objs_found)   #rescale coordinates to original image's resolution
+    objs_found=face_detector.predict(image)
     h,w=image.shape[:2]
 
     tree=fr_helper.objs_found_to_xml("test.jpg",w,h,objs_found)

app/demo/routes.py

@@ -87,8 +87,7 @@ def set_crops():
     face_detector.image_size=get_image_size(session["demo"]['settings']['db_mode'])
     print(face_detector.image_size)
 
-    _,objs_found=face_detector.predict(image)
-    objs_found=face_detector.square_preprocessing.rescale(objs_found)   #rescale coordinates to original image's resolution
+    objs_found=face_detector.predict(image)
     print(image.shape)
     all_aligned_crops=fd_get_crops(image,objs_found,aligner_obj,resize=(face_recognizer.model_config.input_size,face_recognizer.model_config.input_size))
     all_aligned_crops_base64=[]
@@ -156,8 +155,7 @@ def face_recognition():
     
     face_detector.image_size=get_image_size(session["demo"]['settings']['fr_mode'])
     
-    _,objs_found=face_detector.predict(image)
-    objs_found=face_detector.square_preprocessing.rescale(objs_found)   #rescale coordinates to original image's resolution
+    objs_found=face_detector.predict(image)
     h,w=image.shape[:2]
     
     tree=fr_helper.objs_found_to_xml("test.jpg",w,h,objs_found)

app/user/routes.py

@@ -326,9 +326,7 @@ def get_crops():
     print(image.shape)
     # do your deep learning work
     face_detector.image_size=get_image_size(settings['db_mode'])
-    _,objs_found=face_detector.predict(image)
-    
-    objs_found=face_detector.square_preprocessing.rescale(objs_found)   #rescale coordinates to original image's resolution
+    objs_found=face_detector.predict(image)
     print(image.shape)
       
     all_aligned_crops=fd_get_crops(image,objs_found,aligner_obj,resize=(face_recognizer.model_config.input_size,face_recognizer.model_config.input_size))
@@ -417,15 +415,14 @@ def face_recognition():
     # face_recognizer.set_face_db_and_mode(faces=faces,db_faces_features=db_faces_features,distance_mode="avg",recognition_mode="repeat")
     face_recognizer.set_face_db_and_mode(faces=faces,db_faces_features=db_faces_features,distance_mode="best",recognition_mode="repeat")
     
-    _,objs_found=face_detector.predict(image)
-
-    objs_found=face_detector.square_preprocessing.rescale(objs_found)   #rescale coordinates to original image's resolution
+    objs_found=face_detector.predict(image)
     h,w=image.shape[:2]
 
     tree=fr_helper.objs_found_to_xml("test.jpg",w,h,objs_found)
+    
     tree=face_recognizer.predict(image,tree)
+    
     pred_img=fr_helper.show_pred_image(tree,image)
-
     pred_img=image_to_base64(pred_img)
 
     objs_found=fr_helper.xml_to_objs_found(tree)

face_detection/decode_yolo_v2.py

@@ -8,7 +8,7 @@ from face_detection.config import cell_size,idx_to_class,class_to_idx,class_colo
 
 
 
-def get_objects(y_pred,p=0.5,decode_preds=True,idx=None):
+def get_objects(y_pred,p=0.5,decode_preds=True):
   global tf_anchors
   output_size=y_pred.shape[1]
   image_size=cell_size*output_size
@@ -42,46 +42,87 @@ def get_objects(y_pred,p=0.5,decode_preds=True,idx=None):
       obj_name=idx_to_class[obj[4]]
       
       
-      obj_details={'p':prob,'xywh':list(obj[:-1]/output_size),'class_idx':int(obj[4]),'class':obj_name}  # xywh are scaled 0 to 1
-      if idx is not None:obj_details['idx']=idx
+      # obj_details={'p':prob,'xywh':list(obj[:-1]/output_size),'class_idx':int(obj[4]),'class':obj_name}  # xywh are scaled 0 to 1
+      obj_details=[prob,obj[4],*list(obj[:-1]/output_size)]  # xywh are scaled 0 to 1 [P,C_IDX,X,Y,W,H]
       objs_found.append(obj_details)
-  return objs_found
+  return np.array(objs_found)
 
 def list_get_iou(bboxes1, bboxes2):
+  # bboxes has xywh => xmin,ymin,width,height
+  bboxes1 = [bboxes1[0],bboxes1[1],bboxes1[0]+bboxes1[2],bboxes1[1]+bboxes1[3]]
+  bboxes2 = [bboxes2[0],bboxes2[1],bboxes2[0]+bboxes2[2],bboxes2[1]+bboxes2[3]]
 
-    bboxes1 = [bboxes1[0],bboxes1[1],bboxes1[0]+bboxes1[2],bboxes1[1]+bboxes1[3]]
-    bboxes2 = [bboxes2[0],bboxes2[1],bboxes2[0]+bboxes2[2],bboxes2[1]+bboxes2[3]]
+  xA = max(bboxes1[0], bboxes2[0])
+  yA = max(bboxes1[1], bboxes2[1])
+  xB = min(bboxes1[2], bboxes2[2])
+  yB = min(bboxes1[3], bboxes2[3])
 
-    xA = max(bboxes1[0], bboxes2[0])
-    yA = max(bboxes1[1], bboxes2[1])
-    xB = min(bboxes1[2], bboxes2[2])
-    yB = min(bboxes1[3], bboxes2[3])
+  intersection_area = max(0, xB - xA ) * max(0, yB - yA )
 
-    intersection_area = max(0, xB - xA ) * max(0, yB - yA )
+  box1_area = (bboxes1[2] - bboxes1[0] ) * (bboxes1[3] - bboxes1[1] )
+  box2_area = (bboxes2[2] - bboxes2[0] ) * (bboxes2[3] - bboxes2[1] )
 
-    box1_area = (bboxes1[2] - bboxes1[0] ) * (bboxes1[3] - bboxes1[1] )
-    box2_area = (bboxes2[2] - bboxes2[0] ) * (bboxes2[3] - bboxes2[1] )
+  iou = intersection_area / float(box1_area + box2_area - intersection_area+1e-6)
 
-    iou = intersection_area / float(box1_area + box2_area - intersection_area+1e-6)
+  return iou
 
-    return iou
+def np_iou(bboxes1,bboxes2):
+  # bboxes has xywh => xmin,ymin,width,height
+  
+  boxes1_x1 = bboxes1[:,0]
+  boxes1_y1 = bboxes1[:,1]
+  boxes1_x2 = boxes1_x1 + bboxes1[:,2]
+  boxes1_y2 = boxes1_y1 + bboxes1[:,3]
+  
+  boxes2_x1 = bboxes2[:,0]
+  boxes2_y1 = bboxes2[:,1]
+  boxes2_x2 = boxes2_x1 + bboxes2[:,2]
+  boxes2_y2 = boxes2_y1 + bboxes2[:,3]          
+
+  
+  xmins = np.maximum(boxes1_x1,boxes2_x1)
+  ymins = np.maximum(boxes1_y1,boxes2_y1)
+  
+  xmaxs = np.minimum(boxes1_x2,boxes2_x2)
+  ymaxs = np.minimum(boxes1_y2,boxes2_y2)
+
+
+
+  intersection = np.clip((xmaxs-xmins),0,None)*np.clip((ymaxs-ymins),0,None)
+  
+  union = (boxes1_x2-boxes1_x1)*(boxes1_y2-boxes1_y1) + (boxes2_x2-boxes2_x1)*(boxes2_y2-boxes2_y1)
+  ious=intersection/((union-intersection)+1e-6)
+  
+  return ious
 
 def nms(objs_found,iou_threshold=0.2):
-  objs_found=np.array(copy.deepcopy(objs_found))
+  '''objs_found list of list:[
+                                [p,c_idx,x,y,w,h],
+                                [p,c_idx,x,y,w,h]
+                             ]
+  '''
+  if objs_found.size<2 or iou_threshold==1: return objs_found
+
+  objs_found=objs_found[np.argsort(objs_found[:,0])[::-1] ]# This was very important
+  
   best_boxes=[]
   while len(objs_found)>0:
     obj=objs_found[0]
-    objs_found=objs_found[1:]
+    best_boxes.append(list(obj))
+    objs_found=objs_found[1:].reshape(-1,6)
+    
+    if len(objs_found)>0:
 
-    delete_idx=[]
-    for b_idx,b in enumerate(objs_found):
+      same_class_idxs=np.where(objs_found[:,1]==obj[1])[0]  # same class_idx
+      same_class_objs=objs_found[same_class_idxs].reshape(-1,6)
+      
+      ious=np_iou(obj[None,2:],same_class_objs[:,2:])
+      
+      delete_idxs=same_class_idxs[np.where(ious>= iou_threshold)[0]]
 
-      if obj['class_idx']==b['class_idx']:
-        iou=list_get_iou(obj['xywh'],b['xywh'])
-        if iou>= iou_threshold:
-          delete_idx.append(b_idx)
-    objs_found=np.delete(objs_found,delete_idx)
-    best_boxes.append(obj)
+      objs_found=np.delete(objs_found,delete_idxs,axis=0)
+    
+    
   return best_boxes
 
 def show_objects(img,objs_found,return_img=False):
@@ -105,10 +146,10 @@ def pred_image(img,objs_found,font_scale=2,thickness=4):
     return obj_found
 
   for i in range(len(objs_found)):  
-    p=objs_found[i]['p']
-    # obj=np.array(objs_found[i]['xywh'])*img.shape[0]
-    obj=rescale(objs_found[i]['xywh'],img.shape[1],img.shape[0])
-    obj_name=objs_found[i]['class']
+    # p,c_idx,x,y,w,h
+    p=objs_found[i][0]
+    obj_name=objs_found[i][1]
+    obj=rescale(objs_found[i][2:],img.shape[1],img.shape[0])
     
     img=cv2.rectangle(img,(int(obj[0]),int(obj[1])),(int(obj[0]+obj[2]),int(obj[1]+obj[3])),(class_colors[obj_name]*255),thickness)
     img=cv2.putText(img,obj_name,(int(obj[0]),int(obj[1])),cv2.FONT_HERSHEY_SIMPLEX,font_scale, (0,0,0), thickness, lineType=cv2.LINE_AA)

face_detection/helper.py

@@ -9,8 +9,8 @@ def get_crops(img,objs_found,aligner=None,resize:tuple=None):
     img_h,img_w,_=img.shape
     all_crops=[]
     for obj_found in objs_found:
-        xmin,ymin=obj_found['xywh'][0],obj_found['xywh'][1]
-        xmax,ymax=xmin+obj_found['xywh'][2],ymin+obj_found['xywh'][3]
+        xmin,ymin=obj_found[2],obj_found[3]
+        xmax,ymax=xmin+obj_found[4],ymin+obj_found[5]
         # rescale them
         xmin,ymin=int(xmin*img_w),int(ymin*img_h)
         xmax,ymax=int(xmax*img_w),int(ymax*img_h)

face_detection/inference.py

@@ -75,10 +75,10 @@ class square_pad:
     def rescale(self,objs_found):
         
         for i in range(len(objs_found)):
-            objs_found[i]['xywh'][0]=(objs_found[i]['xywh'][0]-self.w_added)/(1-2*self.w_added)
-            objs_found[i]['xywh'][1]=(objs_found[i]['xywh'][1]-self.h_added)/(1-2*self.h_added)
-            objs_found[i]['xywh'][2]=(objs_found[i]['xywh'][2])/(1-2*self.w_added)
-            objs_found[i]['xywh'][3]=(objs_found[i]['xywh'][3])/(1-2*self.h_added)
+            objs_found[i][2]=(objs_found[i][2]-self.w_added)/(1-2*self.w_added)
+            objs_found[i][3]=(objs_found[i][3]-self.h_added)/(1-2*self.h_added)
+            objs_found[i][4]=(objs_found[i][4])/(1-2*self.w_added)
+            objs_found[i][5]=(objs_found[i][5])/(1-2*self.h_added)
         return objs_found
 
 
@@ -208,7 +208,7 @@ class face_detection:
             resized_img=cv2.resize(img,[self.image_size,self.image_size])
             objs_found=self.invoke_model(resized_img[None,:,:,:],self.p_thres,self.nms_thres,batch_size=1)[0]
 
-        return img,objs_found
+        return objs_found
 
     def predict(self,img):
 
@@ -235,14 +235,18 @@ class face_detection:
             all_image_size=copy.deepcopy(self.image_size)
             for image_size in all_image_size:
                 self.image_size=image_size
-                _,objs_found=self.predict_once(img)
+                objs_found=self.predict_once(img)
                 all_objs_found.extend(objs_found)
             self.image_size=all_image_size
         
-        all_objs_found=sorted(all_objs_found,reverse=True,key=lambda x:x["p"]) # This was very important
+        all_objs_found=np.array(all_objs_found)
+        
         all_objs_found=nms(all_objs_found,self.nms_thres)
-
-        return img,all_objs_found
+        all_objs_found=self.square_preprocessing.rescale(all_objs_found)   #rescale coordinates to original image's resolution
+        for obj_found in all_objs_found: obj_found[1]=idx_to_class[obj_found[1]]
+        # print(all_objs_found)
+        
+        return all_objs_found
 
 
 

face_recognition/helper.py

@@ -16,7 +16,7 @@ def show_pred_image(tree,img):
 
         xmin,ymin , xmax,ymax=int(bndbox.find('xmin').text),int(bndbox.find('ymin').text),int(bndbox.find('xmax').text),int(bndbox.find('ymax').text)
 
-        if classname=="face":
+        if obj.find("distance") is None:
             color=default_color  
         else:
             color=random_color
@@ -89,22 +89,22 @@ def objs_found_to_xml(test_img,w,h,objs_found):
 
     # add all objects
     for obj_found in objs_found:
-        obj_found['xywh']=rescale(obj_found['xywh'],w,h)
+        obj_found[2:]=rescale(obj_found[2:],w,h)
 
         obj_tag=ET.Element("object")
         name_tag=ET.Element("name")
-        name_tag.text=obj_found['class']
+        name_tag.text=obj_found[1]
         obj_tag.append(name_tag)
 
         bndbox_tag=ET.Element("bndbox")
         xmin_tag=ET.Element("xmin")
-        xmin_tag.text=str(int(obj_found['xywh'][0]))
+        xmin_tag.text=str(int(obj_found[2]))
         ymin_tag=ET.Element("ymin")
-        ymin_tag.text=str(int(obj_found['xywh'][1]))
+        ymin_tag.text=str(int(obj_found[3]))
         xmax_tag=ET.Element("xmax")
-        xmax_tag.text=str(int(obj_found['xywh'][0]+obj_found['xywh'][2]))
+        xmax_tag.text=str(int(obj_found[2]+obj_found[4]))
         ymax_tag=ET.Element("ymax")
-        ymax_tag.text=str(int(obj_found['xywh'][1]+obj_found['xywh'][3]))
+        ymax_tag.text=str(int(obj_found[3]+obj_found[5]))
 
         bndbox_tag.append(xmin_tag)
         bndbox_tag.append(ymin_tag)

test copy.py

@@ -0,0 +1,6 @@
+import numpy as np
+import cv2
+import face_detection as fd
+
+fd
+