Rilevare faccia poi ritaglio immagini

Sto cercando un’app che consente di rilevare i volti nelle mie foto, rendono il volto rilevato centrato e raccolto 720 x 720 pixel dell’immagine. Si tratta piuttosto di molto il tempo & meticolosa per modificare centinaia di foto che ho intenzione di fare.

Ho provato a fare questo utilizzando python opencv menzionati qui ma penso che non è aggiornato. Ho anche provato utilizza questo ma anche mi dà un errore nel mio sistema. Provato anche con il rilevamento del viso plugin per GIMP, ma è stato progettato per GIMP 2.6, ma sto usando 2.8 su una base regolare. Ho anche provato a fare ciò che è stato inviato ad altissima blog, ma è molto datato (dato che sto usando un Preciso derivata di Ubuntu, mentre il blogpost risale a quando era ancora Hardy). Provato anche utilizzando Phatch ma non c’è il rilevamento del viso così alcuni ritagliate le immagini hanno il loro fronte di taglio a destra fuori.

Ho provato di tutto quanto sopra e sprecato mezza giornata cercando di fare una qualsiasi delle suddette fare quello che dovevo fare.

Voi ragazzi avete un suggerimento per il raggiungimento di un obiettivo di circa 800 foto che ho.

Il mio sistema operativo è Linux Mint 13 MATE.

Nota: avevo intenzione di aggiungere altri 2 link, ma stackexchange mi ha impedito di postare due link in quanto non ho molta reputazione di sicurezza.

  • Non so se questa domanda è sull’argomento o non qui, così ho iniziato una meta discussione solo che, vedi di più qui: meta.photo.stackexchange.com/questions/2606/…
  • In realtà sto solo cercando di trovare una soluzione per il rilevamento volti poi ritagliare l’immagine. Così succede che sto usando un non così facile da usare, sistema operativo che richiede un po ‘ di programmazione per realizzare le cose, che è Linux. La risposta di @jrista è qualcosa in sintesi di cosa voglio spiegare qui. In ogni modo, grazie per la risposta, dpollitt
  • Vorrei perseguire le opencv opzione. opencv è molto potente e aggiornato. Se non si conosce python, potrebbe essere più difficile. Se ho tempo questo fine settimana proverò a attraverso un po ‘ di codice insieme. BTW, quale versione di opencv e python hai?
  • Probabilmente ho solo bisogno di leggere completamente opencv e fare qualche prova ed errore. Il motivo per cui ho detto che è obsoleto perché il blog che ho trovato da google era vecchio e non funziona più. Penso di aver installato la libreria opencv 2.4.1 tramite un tutorial che ho trovato facendo ricerche su google. La mia versione di python è 2.7.3. Ho una conoscenza di con Python, ma non posso dire che io sono veramente un esperto. (come ho disperatamente bisogno recensione su la lingua il mio lavoro a tempo pieno usa C e C++ – lingue in modo che altri tendono lentamente a dimenticare)
InformationsquelleAutor AisIceEyes | 2012-11-01

 

11 Replies
  1. 88

    Io sono riuscito a prendere pezzi di codice da varie fonti e cucire insieme. È ancora un work in progress. Inoltre, hai qualche esempio immagini?

    '''
    Sources:
    http://pythonpath.wordpress.com/2012/05/08/pil-to-opencv-image/
    http://www.lucaamore.com/?p=638
    '''
    
    #Python 2.7.2
    #Opencv 2.4.2
    #PIL 1.1.7
    
    import cv
    import Image
    
    def DetectFace(image, faceCascade):
        #modified from: http://www.lucaamore.com/?p=638
    
        min_size = (20,20)
        image_scale = 1
        haar_scale = 1.1
        min_neighbors = 3
        haar_flags = 0
    
        # Allocate the temporary images
        smallImage = cv.CreateImage(
                (
                    cv.Round(image.width / image_scale),
                    cv.Round(image.height / image_scale)
                ), 8 ,1)
    
        # Scale input image for faster processing
        cv.Resize(image, smallImage, cv.CV_INTER_LINEAR)
    
        # Equalize the histogram
        cv.EqualizeHist(smallImage, smallImage)
    
        # Detect the faces
        faces = cv.HaarDetectObjects(
                smallImage, faceCascade, cv.CreateMemStorage(0),
                haar_scale, min_neighbors, haar_flags, min_size
            )
    
        # If faces are found
        if faces:
            for ((x, y, w, h), n) in faces:
                # the input to cv.HaarDetectObjects was resized, so scale the
                # bounding box of each face and convert it to two CvPoints
                pt1 = (int(x * image_scale), int(y * image_scale))
                pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
                cv.Rectangle(image, pt1, pt2, cv.RGB(255, 0, 0), 5, 8, 0)
    
        return image
    
    def pil2cvGrey(pil_im):
        #from: http://pythonpath.wordpress.com/2012/05/08/pil-to-opencv-image/
        pil_im = pil_im.convert('L')
        cv_im = cv.CreateImageHeader(pil_im.size, cv.IPL_DEPTH_8U, 1)
        cv.SetData(cv_im, pil_im.tostring(), pil_im.size[0]  )
        return cv_im
    
    def cv2pil(cv_im):
        return Image.fromstring("L", cv.GetSize(cv_im), cv_im.tostring())
    
    
    pil_im=Image.open('testPics/faces.jpg')
    cv_im=pil2cv(pil_im)
    #the haarcascade files tells opencv what to look for.
    faceCascade = cv.Load('C:/Python27/Lib/site-packages/opencv/haarcascade_frontalface_default.xml')
    face=DetectFace(cv_im,faceCascade)
    img=cv2pil(face)
    img.show()

    Test sulla prima pagina di Google (su google “facce”):
    Rilevare faccia poi ritaglio immagini


    Aggiornamento

    Questo codice dovrebbe fare esattamente quello che vuoi. Fatemi sapere se avete domande. Ho cercato di includere un sacco di commenti nel codice:

    '''
    Sources:
    http://opencv.willowgarage.com/documentation/python/cookbook.html
    http://www.lucaamore.com/?p=638
    '''
    
    #Python 2.7.2
    #Opencv 2.4.2
    #PIL 1.1.7
    
    import cv #Opencv
    import Image #Image from PIL
    import glob
    import os
    
    def DetectFace(image, faceCascade, returnImage=False):
        # This function takes a grey scale cv image and finds
        # the patterns defined in the haarcascade function
        # modified from: http://www.lucaamore.com/?p=638
    
        #variables    
        min_size = (20,20)
        haar_scale = 1.1
        min_neighbors = 3
        haar_flags = 0
    
        # Equalize the histogram
        cv.EqualizeHist(image, image)
    
        # Detect the faces
        faces = cv.HaarDetectObjects(
                image, faceCascade, cv.CreateMemStorage(0),
                haar_scale, min_neighbors, haar_flags, min_size
            )
    
        # If faces are found
        if faces and returnImage:
            for ((x, y, w, h), n) in faces:
                # Convert bounding box to two CvPoints
                pt1 = (int(x), int(y))
                pt2 = (int(x + w), int(y + h))
                cv.Rectangle(image, pt1, pt2, cv.RGB(255, 0, 0), 5, 8, 0)
    
        if returnImage:
            return image
        else:
            return faces
    
    def pil2cvGrey(pil_im):
        # Convert a PIL image to a greyscale cv image
        # from: http://pythonpath.wordpress.com/2012/05/08/pil-to-opencv-image/
        pil_im = pil_im.convert('L')
        cv_im = cv.CreateImageHeader(pil_im.size, cv.IPL_DEPTH_8U, 1)
        cv.SetData(cv_im, pil_im.tostring(), pil_im.size[0]  )
        return cv_im
    
    def cv2pil(cv_im):
        # Convert the cv image to a PIL image
        return Image.fromstring("L", cv.GetSize(cv_im), cv_im.tostring())
    
    def imgCrop(image, cropBox, boxScale=1):
        # Crop a PIL image with the provided box [x(left), y(upper), w(width), h(height)]
    
        # Calculate scale factors
        xDelta=max(cropBox[2]*(boxScale-1),0)
        yDelta=max(cropBox[3]*(boxScale-1),0)
    
        # Convert cv box to PIL box [left, upper, right, lower]
        PIL_box=[cropBox[0]-xDelta, cropBox[1]-yDelta, cropBox[0]+cropBox[2]+xDelta, cropBox[1]+cropBox[3]+yDelta]
    
        return image.crop(PIL_box)
    
    def faceCrop(imagePattern,boxScale=1):
        # Select one of the haarcascade files:
        #   haarcascade_frontalface_alt.xml  <-- Best one?
        #   haarcascade_frontalface_alt2.xml
        #   haarcascade_frontalface_alt_tree.xml
        #   haarcascade_frontalface_default.xml
        #   haarcascade_profileface.xml
        faceCascade = cv.Load('haarcascade_frontalface_alt.xml')
    
        imgList=glob.glob(imagePattern)
        if len(imgList)<=0:
            print 'No Images Found'
            return
    
        for img in imgList:
            pil_im=Image.open(img)
            cv_im=pil2cvGrey(pil_im)
            faces=DetectFace(cv_im,faceCascade)
            if faces:
                n=1
                for face in faces:
                    croppedImage=imgCrop(pil_im, face[0],boxScale=boxScale)
                    fname,ext=os.path.splitext(img)
                    croppedImage.save(fname+'_crop'+str(n)+ext)
                    n+=1
            else:
                print 'No faces found:', img
    
    def test(imageFilePath):
        pil_im=Image.open(imageFilePath)
        cv_im=pil2cvGrey(pil_im)
        # Select one of the haarcascade files:
        #   haarcascade_frontalface_alt.xml  <-- Best one?
        #   haarcascade_frontalface_alt2.xml
        #   haarcascade_frontalface_alt_tree.xml
        #   haarcascade_frontalface_default.xml
        #   haarcascade_profileface.xml
        faceCascade = cv.Load('haarcascade_frontalface_alt.xml')
        face_im=DetectFace(cv_im,faceCascade, returnImage=True)
        img=cv2pil(face_im)
        img.show()
        img.save('test.png')
    
    
    # Test the algorithm on an image
    #test('testPics/faces.jpg')
    
    # Crop all jpegs in a folder. Note: the code uses glob which follows unix shell rules.
    # Use the boxScale to scale the cropping area. 1=opencv box, 2=2x the width and height
    faceCrop('testPics/*.jpg',boxScale=1)

    Utilizzando l’immagine sopra, questo codice estratti 52 di 59 facce, producendo ritagliata file, ad esempio:
    Rilevare faccia poi ritaglio immagini

    • Wow. Che bel codice! Grazie per passare il tempo su questo. Solo wow! Si prova quando ho il tempo durante le pause in ufficio (come -ber mesi tendono ad essere ack inferno, rispettare le scadenze dei clienti per le vacanze)
    • Grazie, il codice è un inizio. Sto lavorando su come ottenere il codice per fare esattamente quello che vuoi.
    • Ho appena aggiornato la mia risposta. Che dovrebbe fare il trucco. Fatemi sapere se avete domande.
    • Scusate se non ho ottenuto indietro come io onestamente non completamente testato il bel codice che hai fatto. Io sono purtroppo ancora occupato al momento, ma sono fiducioso che posso fare un test di questo prima di febbraio è finita. Grazie ancora per questo Onlyjus!
    • Fresco uomo! Stackoverflow bisogno di persone generose come te… È utile per me, dopo due anni..
    • Bene! Non ho testato il codice con le ultime versioni. Speriamo che funziona ancora?
    • Ancora buona per andare a 3 anni! Grazie tanto per la fatica!!!
    • Con l’ultima versione di OpenCV, si può fare questo con molto meno codice.
    • Stavo solo cercando un modo per migliorare la mia auto-resize/coltura script. Questo è perfetto. Immagino che io so quello che sto facendo in questo fine settimana! Grazie mille!
    • Ho eseguito il codice e trovare un errore: faceCascade = cv.Load(‘haarcascade_frontalface_alt.xml’) TypeError: OpenCV restituito NULL. Come risolvere questo bug?
    • controllare per vedere se il file esiste. os.path.exists('haarcascade_frontalface_alt.xml') Questi file dovrebbe essere incluso con opencv. Oppure li puoi scaricare da qui: github.com/Itseez/opencv/tree/master/data/haarcascades
    • Restituisce false, quindi non esiste. Ho scaricato la libreria opencv. che percorso fa uso python per il collegamento di opencv (o dove devo installare il mio opencv)? Grazie per il vostro aiuto?
    • dovrebbe essere qualcosa di simile a opencv/share/OpenCV/haarcascades/
    • l’aggiornamento all’ultima versione di opencv
    • C’è una versione di questo codice python 3.5? Molti componenti di aprire cv sono stati deprecati in cv2 versione compatibile con la 3.5
    • Come altri hanno commentato, purtroppo gran parte di questo non sembra funzionare con le versioni di sopra dei 3 più

  2. 12

    Un’altra opzione disponibile è dlib, che si basa su approcci di apprendimento automatico.

    import dlib
    import Image
    from skimage import io
    import matplotlib.pyplot as plt
    
    
    def detect_faces(image):
    
        # Create a face detector
        face_detector = dlib.get_frontal_face_detector()
    
        # Run detector and get bounding boxes of the faces on image.
        detected_faces = face_detector(image, 1)
        face_frames = [(x.left(), x.top(),
                        x.right(), x.bottom()) for x in detected_faces]
    
        return face_frames
    
    # Load image
    img_path = 'test.jpg'
    image = io.imread(img_path)
    
    # Detect faces
    detected_faces = detect_faces(image)
    
    # Crop faces and plot
    for n, face_rect in enumerate(detected_faces):
        face = Image.fromarray(image).crop(face_rect)
        plt.subplot(1, len(detected_faces), n+1)
        plt.axis('off')
        plt.imshow(face)

    Rilevare faccia poi ritaglio immagini
    Rilevare faccia poi ritaglio immagini

    • Questo funziona alla grande. Questa è la prima volta che ho provato dlib. L’unico problema è che si mostra solo una faccia di due facce nell’immagine che sto usando. Avete qualche idea del perché questo accade? Ho copiato il tuo codice esatto. …MODIFICARE questo accade solo in alcune immagini, ma in alcune altre immagini che mostra tutte le facce.
  3. 12

    facedetect

    https://github.com/wavexx/facedetect è un bel Pitone OpenCV CLI wrapper, e ho appena aggiunto che esempio per i loro README usando ImageMagick:

    for file in path/to/pictures/*.jpg; do
      name=$(basename "$file")
      i=0
      facedetect "$file" | while read x y w h; do
        convert "$file" -crop ${w}x${h}+${x}+${y} "path/to/faces/${name%.*}_${i}.${name##*.}"
        i=$(($i+1))
      done
    done

    Testato su Ubuntu 16.04 con migliaia di (senza etichetta) Facebook le immagini del profilo, vedere: https://github.com/cirosantilli/art/tree/d4352a46064d156591817c4eae5199f5ac8f23be/facebook

    • Molto bello, grazie!
    • Avevo bisogno di cambiare l’individuazione di facedetect "$file" | grep -v INFO | while read x y w h; do perché ho continuato a ottenere [ INFO:0] Initialize OpenCL runtime... come prima linea di uscita
    • Inoltre, per qualche motivo incremento non ha funzionato nel mio zsh shell, ma non è necessario: basta usare questo la conversione di linea: convert "$file" -crop ${w}x${h}+${x}+${y} "crop_$file"
  4. 5

    Questo suona come potrebbe essere una domanda migliore per uno dei più (computer) tecnologia focalizzata scambi.

    Detto questo, hai guardato in qualcosa di simile a questo jquery face detection script? Non so come esperti si sono, ma è una possibilità che è indipendente dal sistema operativo.

    Questa soluzione , inoltre, sembra promettente, ma richiederebbe di Windows.

    • Thankd per la risposta @ckoerner. Voglio fare un po ‘ scavare su tuo suggerimento & cercherà di utilizzare jquery link che ti hanno dato (anche se io onestamente recensione su di esso). Non penso di essere in grado di utilizzare Windows come non ho un sistema operativo Windows computer & di non avere un programma di installazione (e nessun piano di pirateria uno). Grazie di nuovo.
  5. 4

    codici di cui sopra il lavoro, ma questa è la più recente implementazione utilizzo di OpenCV
    Non mi è stato possibile eseguire il sopra, il più recente e ha trovato qualcosa che funziona (da vari luoghi)

    import cv2
    import os
    
    def facecrop(image):
        facedata = "haarcascade_frontalface_alt.xml"
        cascade = cv2.CascadeClassifier(facedata)
    
        img = cv2.imread(image)
    
        minisize = (img.shape[1],img.shape[0])
        miniframe = cv2.resize(img, minisize)
    
        faces = cascade.detectMultiScale(miniframe)
    
       for f in faces:
            x, y, w, h = [ v for v in f ]
            cv2.rectangle(img, (x,y), (x+w,y+h), (255,255,255))
    
            sub_face = img[y:y+h, x:x+w]
            fname, ext = os.path.splitext(image)
            cv2.imwrite(fname+"_cropped_"+ext, sub_face)
    
    
    
        return
    
    
    
    facecrop("1.jpg")
  6. 2

    Il ritaglio automatico funzionato per me abbastanza bene.
    E ‘ facile come autocrop -i pics -o crop -w 400 -H 400.
    È possibile ottenere l’utilizzo nelle loro file readme.

    usage: [-h] [-o OUTPUT] [-i INPUT] [-w WIDTH] [-H HEIGHT] [-v]
    
    Automatically crops faces from batches of pictures
    
    optional arguments:
      -h, --help            Show this help message and exit
      -o, --output, -p, --path
                Folder where cropped images will be placed.
                Default: current working directory
      -i, --input
                Folder where images to crop are located.
                Default: current working directory
      -w, --width
                Width of cropped files in px. Default=500
      -H, --height
                Height of cropped files in px. Default=500
      -v, --version         Show program's version number and exit
    • Non c’è documentazione, si può bit help me come usare questo
    • il file è auto-esplicativo e ben dettagliate. Che tipo di aiuto hai bisogno in particolare?
  7. 2

    Ho sviluppato un’applicazione “Riconoscimento del Volto-con-Propri-Dati-Set” utilizzando il pacchetto python ‘face_recognition’ e ‘opencv-python’.

    Il codice sorgente e la guida all’installazione è in GitHub – Il Riconoscimento del volto-con-Propri-Dati-Set

    O eseguire la fonte –

    import face_recognition
    import cv2
    import numpy as np
    
    import os
    '''
        Get current working director and create a Data directory to store the faces
    '''
    currentDirectory = os.getcwd()
    dirName = os.path.join(currentDirectory, 'Data')
    print(dirName)
    if not os.path.exists(dirName):
        try:
            os.makedirs(dirName)
        except:
            raise OSError("Can't create destination directory (%s)!" % (dirName))
    '''
        For the given path, get the List of all files in the directory tree 
    '''
    def getListOfFiles(dirName):
        # create a list of file and sub directories
        # names in the given directory
        listOfFile = os.listdir(dirName)
        allFiles = list()
        # Iterate over all the entries
        for entry in listOfFile:
            # Create full path
            fullPath = os.path.join(dirName, entry)
            # If entry is a directory then get the list of files in this directory
            if os.path.isdir(fullPath):
                allFiles = allFiles + getListOfFiles(fullPath)
            else:
                allFiles.append(fullPath)
    
        return allFiles
    
    def knownFaceEncoding(listOfFiles):
        known_face_encodings=list()
        known_face_names=list()
        for file_name in listOfFiles:
            # print(file_name)
            if(file_name.lower().endswith(('.png', '.jpg', '.jpeg'))):
                known_image = face_recognition.load_image_file(file_name)
                # known_face_locations = face_recognition.face_locations(known_image)
                # known_face_encoding = face_recognition.face_encodings(known_image,known_face_locations)
                face_encods = face_recognition.face_encodings(known_image)
                if face_encods:
                    known_face_encoding = face_encods[0]
                    known_face_encodings.append(known_face_encoding)
                    known_face_names.append(os.path.basename(file_name[0:-4]))
        return known_face_encodings, known_face_names
    
    
    # Get the list of all files in directory tree at given path
    listOfFiles = getListOfFiles(dirName)
    known_face_encodings, known_face_names = knownFaceEncoding(listOfFiles)
    
    video_capture = cv2.VideoCapture(0)
    cv2.namedWindow("Video", flags= cv2.WINDOW_NORMAL)
    # cv2.namedWindow("Video")
    
    cv2.resizeWindow('Video', 1024,640)
    cv2.moveWindow('Video', 20,20)
    
    
    # Initialize some variables
    face_locations = []
    face_encodings = []
    face_names = []
    process_this_frame = True
    
    
    while True:
        # Grab a single frame of video
        ret, frame = video_capture.read()
        # print(ret)
        # Resize frame of video to 1/4 size for faster face recognition processing
        small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)
        # Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses)
        rgb_small_frame = small_frame[:, :, ::-1]
    
    
        k = cv2.waitKey(1)
        # Hit 'c' on capture the image!
        # Hit 'q' on the keyboard to quit!
        if k == ord('q'):
            break
        elif k== ord('c'):
            face_loc = face_recognition.face_locations(rgb_small_frame)
            if face_loc:
                print("Enter Name -")
                name = input()
                img_name = "{}/{}.png".format(dirName,name)
                (top, right, bottom, left)= face_loc[0]
                top *= 4
                right *= 4
                bottom *= 4
                left *= 4
                cv2.imwrite(img_name, frame[top - 5 :bottom + 5,left -5 :right + 5])
                listOfFiles = getListOfFiles(dirName)
                known_face_encodings, known_face_names = knownFaceEncoding(listOfFiles)
    
        # Only process every other frame of video to save time
        if process_this_frame:
            # Find all the faces and face encodings in the current frame of video
            face_locations = face_recognition.face_locations(rgb_small_frame)
            face_encodings = face_recognition.face_encodings(rgb_small_frame, face_locations)
            # print(face_locations)
    
            face_names = []
    
            for face_encoding,face_location in zip(face_encodings,face_locations):
                # See if the face is a match for the known face(s)
                matches = face_recognition.compare_faces(known_face_encodings, face_encoding, tolerance= 0.55)
                name = "Unknown"
                distance = 0
    
                # use the known face with the smallest distance to the new face
                face_distances = face_recognition.face_distance(known_face_encodings, face_encoding)
                #print(face_distances)
                if len(face_distances) > 0:
                    best_match_index = np.argmin(face_distances)
                    if matches[best_match_index]:
                        name = known_face_names[best_match_index]
                        # distance = face_distances[best_match_index]
                #print(face_distances[best_match_index])
                # string_value = '{} {:.3f}'.format(name, distance)
                face_names.append(name)
    
    
        process_this_frame = not process_this_frame
    
    
        # Display the results
        for (top, right, bottom, left), name in zip(face_locations, face_names):
            # Scale back up face locations since the frame we detected in was scaled to 1/4 size
            top *= 4
            right *= 4
            bottom *= 4
            left *= 4
    
            # Draw a box around the face
            cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)
    
            # Draw a label with a name below the face
            cv2.rectangle(frame, (left, bottom + 46), (right, bottom+11), (0, 0, 155), cv2.FILLED)
            font = cv2.FONT_HERSHEY_DUPLEX
            cv2.putText(frame, name, (left + 6, bottom +40), font, 1.0, (255, 255, 255), 1)
    
        # Display the resulting image
        cv2.imshow('Video', frame)
    
    # Release handle to the webcam
    video_capture.release()
    cv2.destroyAllWindows()

    Per creare un ‘Dati’ la cartella nella posizione corrente, anche se questa directory non esiste.

    Quando un viso è segnato con un rettangolo, premere ‘c’ per catturare l’immagine e il prompt dei comandi, viene chiesto il nome del viso. Mettere il nome dell’immagine e invio. È possibile trovare questa immagine nella ‘Dati’ directory.

  8. 1

    Ho usato questo comando di shell:

    for f in *.jpg;do PYTHONPATH=/usr/local/lib/python2.7/site-packages python -c 'import cv2;import sys;rects=cv2.CascadeClassifier("/usr/local/opt/opencv/share/OpenCV/haarcascades/haarcascade_frontalface_default.xml").detectMultiScale(cv2.cvtColor(cv2.imread(sys.argv[1]),cv2.COLOR_BGR2GRAY),1.3,5);print("\n".join([" ".join([str(item) for item in row])for row in rects]))' $f|while read x y w h;do convert $f -gravity NorthWest -crop ${w}x$h+$x+$y ${f%jpg}-$x-$y.png;done;done

    È possibile installare opencv e imagemagick su OS X con brew install opencv imagemagick.

  9. 1

    Aggiungendo @Israele Abebe versione. Se si aggiunge un contatore prima di estensione dell’immagine l’algoritmo possa dare a tutti i volti rilevati. Allegando il codice, come Israele Abebe s. Solo l’aggiunta di un contatore e di accettare la cascata del file come argomento. L’algoritmo funziona a meraviglia! Grazie @Israele Abebe per questo!

    import cv2
    import os
    import sys
    
    def facecrop(image):
    facedata = sys.argv[1]
    cascade = cv2.CascadeClassifier(facedata)
    
    img = cv2.imread(image)
    
    minisize = (img.shape[1],img.shape[0])
    miniframe = cv2.resize(img, minisize)
    
    faces = cascade.detectMultiScale(miniframe)
    counter = 0
    for f in faces:
        x, y, w, h = [ v for v in f ]
        cv2.rectangle(img, (x,y), (x+w,y+h), (255,255,255))
    
        sub_face = img[y:y+h, x:x+w]
        fname, ext = os.path.splitext(image)
        cv2.imwrite(fname+"_cropped_"+str(counter)+ext, sub_face)
        counter += 1
    return
    
    facecrop("Face_detect_1.jpg")

    PS: Aggiunta come risposta. Non era in grado di aggiungere un commento a causa di punti di problema.

  10. 1

    Rilevare viso e poi ritagliare e salvare l’immagine ritagliata nella cartella ..

    HTML:

    import numpy as np
    import cv2 as cv
    face_cascade = cv.CascadeClassifier('./haarcascade_frontalface_default.xml')
    #eye_cascade = cv.CascadeClassifier('haarcascade_eye.xml')
    img = cv.imread('./face/nancy-Copy1.jpg')
    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
    for (x,y,w,h) in faces:
        cv.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
        roi_gray = gray[y:y+h, x:x+w]
        roi_color = img[y:y+h, x:x+w]
        #eyes = eye_cascade.detectMultiScale(roi_gray)
        #for (ex,ey,ew,eh) in eyes:
         #   cv.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)
        sub_face = img[y:y+h, x:x+w]
        face_file_name = "face/" + str(y) + ".jpg"
        plt.imsave(face_file_name, sub_face)
    plt.imshow(sub_face)


Lascia un commento