• मैं चेहरों को निकालने के लिए FDDB-DataSet पर काम कर रहा हूं, और वही एक ही छवि से पृष्ठभूमि की गिनती।

  • मैं चेहरे (एनोटेशन के निर्देशांक से) प्राप्त करने में सक्षम था।

  • मेरी परेशानी यह हे कि मे: मैं समान संख्या में चेहरों के साथ बैकग्राउंड पैच क्रॉप करना चाहता हूं (जरूरी नहीं कि एक ही आकार), पृष्ठभूमि पर बाधाएं हैं:

  1. किसी भी बैकग्राउंड इमेज का साइज 20 x 20 पिक्सल से कम नहीं होना चाहिए।
  2. चेहरों के साथ अधिकतम अतिव्यापी अनुपात (उनमें से कोई भी) (IOU: संघ पर प्रतिच्छेदन) 20% (0.2) से अधिक नहीं होना चाहिए।
  3. पृष्ठभूमि पैच की गिनती एक ही छवि में चेहरों की गिनती के समान होनी चाहिए।

नमूना छवि:

Sample Background

एनोटेशन डेटा:

[आरमैक्स रमिन थीटा एक्ससी वाईसी]

[[ 52  38   1 154  72]
 [ 57  38  -2 368 103]
 [ 14   9  -2  11  64]
 [ 11   8   1  29  16]
 [ 10   6   1  56  61]
 [ 10   6  -2  68  66]
 [ 14   9   1  46 126]
 [ 15  11   1  21 192]
 [ 22  12   1  11 157]
 [ 13   9   1 267 133]
 [ 19  13   1 312 186]
 [ 12   9   1 300  19]
 [ 11   9  -2 334 139]
 [ 14  10  -2 437  87]
 [ 11   8   1 232  27]]

मेरा कोड है:

#--------------------
# Import Libraies
#====================
import numpy as np
import matplotlib.pyplot as plt
import os
import cv2

datasetPath = "/home/myPath" 
#---------------------------------------------
# Extract faces, and Backgrounds from an image
#=============================================
def extData(imgPath, annots, foldPath, index):
    '''
    Function to Extract faces, and Backgrounds from an image.
    
    Parameters:
    @Param: imgPath : the specified image path(inside the DB).
    @Param: annots  : nd-array with shape m x 5, : m num of the detected faces in the image.
            (5): max_radius | min_radius | angle | center_x | center_y
    @Param: foldPath : the fold path where to save the extracted images.
    @Param: index : a number to start naming the faces, backgrounds from it.
    
    saves: m nd-array (m Faces), and m nd-array (m Background) in the foldPath
    '''
    fullImagePath = os.path.join(datasetPath, imgPath)
    img = cv2.imread(fullImagePath)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    # Create Faces
    facesList = []
    for row in range(annots.shape[0]):
        # Initialize the Variables
        xc = annots[row][3]
        yc = annots[row][4]
        Rmax = annots[row][0] 
        Rmin =  annots[row][1]
        theta =  annots[row][2]

        # Rectangle Borders 
        # represents the top left corner of rectangle 
        x0 = math.floor(xc - Rmin * math.sin(theta))
        y0 = math.floor(yc - Rmax * math.sin(theta)) 
        # represents the bottom right corner of rectangle 
        x1 = math.floor(xc + Rmin * math.sin(theta))
        y1 = math.floor(yc + Rmax * math.sin(theta))
        # Crop the face in rectangular window
        face = img[y0:y1, x0:x1,:]
        # store the coordinates of the face
        facesList.append([x0, x1, y0, y1])
        # make a directory to save the faces inside.
        os.mkdir(os.path.join(foldPath,"/face/"))
        cv2.imwrite(os.path.join(foldPath,"/face/", "face_{}".format(str(index+row)),face))
    
    # Create Backgrounds
    for row, face in enumerate(facesList):

        # background = img[xb1:xb2,yb1:yb2,:]
        # make a directory to save the backgrounds inside.
        os.mkdir(os.path.join(foldPath,"/background/"))
        # cv2.imwrite(os.path.join(foldPath,"/background/", "background_{}".format(str(index+row)),background))
#---------------------------------------------
0
Bilal 18 अक्टूबर 2020, 00:01

1 उत्तर

सबसे बढ़िया उत्तर

L1 की गणना करने के लिए आप cv2.distanceTransform का उपयोग कर सकते हैं चेहरों से दूरी, और नमूना रेक्ट-सेंटर उनकी दूरी के अनुसार, इस प्रकार यह सुनिश्चित करना कि फसल "चेहरे" के साथ ओवरलैप नहीं होगी:

import numpy as np

img = cv2.imread(fullImagePath)
# create a mask with zeros in "faces" and bonudary
mask = np.zeros(img.shape[:2], dtype=np.uint8)
mask[1:-1, 1:-1] = 1
for row in range(annots.shape[0]):
  # Initialize the Variables
  xc = annots[row][3]
  yc = annots[row][4]
  Rmax = annots[row][0]
  Rmin =  annots[row][1]
  theta =  annots[row][2]
  # in case of rotation angles more than 45 degrees swap radius
  if(theta > 45):
    R = Rmax
    Rmax = Rmin
    Rmin = R
  # Rectangle Borders
  # represents the top left corner of rectangle
  st = math.sin(theta)
  st = st if st > 0 else -st
  x0 = math.floor(xc - Rmin * st)
  y0 = math.floor(yc - Rmax * st)
  # represents the bottom right corner of rectangle
  x1 = math.floor(xc + Rmin * st)
  y1 = math.floor(yc + Rmax * st)
  # Crop the face in rectangular window
  mask[y0:y1, x0:x1] = 0

# once we have a map we can compute the distance of each non-face pixel to the nearest face
dst = cv2.distanceTransform(mask, cv2.DIST_L1, 3)

# pixels that are closer than 10 pixels (20//2) to a face, cannot be considered as good candidates. If you allow for IoU > 0 this can be relaxed a little.
dst[dst<10] = 0

# linear indices of pixels
idx = np.arange(np.prod(img.shape[:2]))

# sample centers
centers = np.random.choice(idx, size=annots.shape[0], replace=False, p=dst.flatten()/dst.sum())

# create the rectangles
windows = []
for i, c in enumerate(centers):
  r = int(np.floor(dst.flat[c]))
  r = np.random.choice(range(10,r))  # sample possible R from 10 to max possible
  [y, x] = np.unravel_index(c, img.shape[:2])
  windows.append((y-r, x-r, y+r, x+r))

परिणामी विंडो का एक उदाहरण यहां दिखाया गया है:

enter image description here

2
Shai 18 अक्टूबर 2020, 11:55