Face_detect_recog_extract.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Face_detect_recog_extract.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "authorship_tag": "ABX9TyOuRwcIeaEyRncxr8vWJQVt",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/joplaete/faceMLtools/blob/main/Face_detect_recog_extract.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3JaVHHmKd9i3"
      },
      "outputs": [],
      "source": [
        "!pip install opencv-python\n",
        "!pip install pillow\n",
        "\n",
        "!pip install face-recognition\n",
        "\n",
        "!wget https://raw.githubusercontent.com/opencv/opencv/master/data/haarcascades/haarcascade_frontalface_alt2.xml"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# make sure you got a gpu runtime!\n",
        "!nvidia-smi"
      ],
      "metadata": {
        "id": "lH32ZEF28G3Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Connect your drive that hosts your files\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "id": "8lU5JD3LltQn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Imports and Supporting Function, run once\n",
        "import face_recognition\n",
        "import cv2\n",
        "from PIL import Image\n",
        "import os, time\n",
        "import numpy as np\n",
        "\n",
        "def image_resize(image, width = None, height = None, inter = cv2.INTER_AREA):\n",
        "    dim = None\n",
        "    (h, w) = image.shape[:2]\n",
        "    if width is None and height is None:\n",
        "        return image\n",
        "    if width is None:\n",
        "        r = height / float(h)\n",
        "        dim = (int(w * r), height)\n",
        "    else:\n",
        "        r = width / float(w)\n",
        "        dim = (width, int(h * r))\n",
        "    resized = cv2.resize(image, dim, interpolation = inter)\n",
        "   return resized"
      ],
      "metadata": {
        "id": "XuBiLmCpl2c_"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Compute encodings for Face Recognition\n",
        "\n",
        "# images of person to find (helps to align them first)\n",
        "person_to_find_images = r\"/content/drive/MyDrive/FACE_RECOG_EXTRACT/PERSON_TO_FIND/daniel_craig/aligned\" # @param str\n",
        "# encodings get saved and re-used if found in folder, unless force_recompute is on\n",
        "force_recompute = True #@param {type:\"boolean\"}\n",
        "\n",
        "encodings_path = os.path.join(person_to_find_images, 'encodings.npy')\n",
        "encodings = []\n",
        "if not force_recompute and os.path.exists(encodings_path):\n",
        "    print('Found and using existing encoding: ', encodings_path)\n",
        "    print('(delete this or enabled force_recompute to recompute when image set has changed)')\n",
        "    encodings = np.load(encodings_path)\n",
        "else:\n",
        "    print('Build face encodings')\n",
        "    for im in os.listdir(person_to_find_images):\n",
        "        if not 'jpg' in im: continue\n",
        "        known_image = face_recognition.load_image_file(os.path.join(person_to_find_images, im))\n",
        "        encoding = face_recognition.face_encodings(known_image)\n",
        "        if len(encoding):\n",
        "            print('-->> Adding: ', im)\n",
        "            encodings.append(encoding[0])\n",
        "np.save(encodings_path, encodings)"
      ],
      "metadata": {
        "id": "Ln9OxXKEoZvm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Find and Extract Recognized faces\n",
        "\n",
        "mp4path = r\"/content/drive/MyDrive/FACE_RECOG_EXTRACT/MEDIA_TO_SEARCH/Daniel Craig James Bond Monologue - SNL.mp4\" # @param str\n",
        "\n",
        "# OUT    \n",
        "out = r\"/content/drive/MyDrive/FACE_RECOG_EXTRACT/OUT/daniel_craig__late_night_show\" # @param str\n",
        "out_prexix = r'out.' # @param str\n",
        "if not os.path.exists(out):\n",
        "    os.mkdir(out)\n",
        "\n",
        "# use 1 not 0 for start \n",
        "start_offset =  500# @param int\n",
        "limit_frames =-1 # @param int # handy for testing, will only compute limit_frames\n",
        "vidcap =  cv2.VideoCapture(mp4path)\n",
        "vidcap.set(cv2.CAP_PROP_POS_FRAMES, start_offset-1)\n",
        "print('cv2.CAP_PROP_POS_FRAMES:',cv2.CAP_PROP_POS_FRAMES)\n",
        "\n",
        "print('\\n START PROCESSING', vidcap)\n",
        "print(mp4path)\n",
        "print(out)\n",
        "print('\\n\\n')\n",
        "\n",
        "success, image = vidcap.read()\n",
        "frame_count = vidcap.get(cv2.CAP_PROP_FRAME_COUNT)\n",
        "face_cascade = cv2.CascadeClassifier(r\"/content/haarcascade_frontalface_alt2.xml\")\n",
        "\n",
        "count = start_offset-1\n",
        "while success:\n",
        "    # cv2.imwrite(\"frame%d.jpg\" % count, image)     # save frame as JPEG file      \n",
        "    # if count < clamp_start or count > clamp_end:\n",
        "    #     count+=1\n",
        "    #     print('skip', count)\n",
        "    #     continue\n",
        "    print('\\nProcess frame: ', count, '/', int(frame_count), '  --  ', round(count/frame_count*100), '%')\n",
        "    # print(mp4path, out)\n",
        "    \n",
        "    success, image = vidcap.read()\n",
        "    if not success:\n",
        "        print('-- FRAME READ FAILED, aborting.')\n",
        "        break\n",
        "\n",
        "    imshowname = os.path.split(mp4path)[1] + ' (RESIZED for PREVIEW)'\n",
        "    # cv2.imshow(imshowname, image_resize(image, height = 800))\n",
        "    # cv2.waitKey(1)\n",
        "\n",
        "    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
        "    \n",
        "    # # Detect faces using opencv\n",
        "    faces = face_cascade.detectMultiScale(gray, 1.1, 5)\n",
        "    print('>> Found', len(faces),'face(s)')\n",
        "    if len(faces) > 6: continue\n",
        "    padding = 150 # @param float # padding for extraction\n",
        "    min_face_size =  60# @param float # skip w or h smaller than this\n",
        "    for i, (x, y, w, h) in enumerate(faces):\n",
        "        print('------ Face', i)\n",
        "        if h < min_face_size: print(f'too small ({min_face_size})'); continue\n",
        "        if w < min_face_size: print(f'too small ({min_face_size})'); continue\n",
        "        preview = image\n",
        "        # preview = cv2.rectangle(image, (x-padding,y-padding), (x+w+padding,y+h+padding), (200,200,200), 15)\n",
        "        # cv2.imshow(imshowname, image_resize(preview, height = 800))\n",
        "        # cv2.waitKey(1)\n",
        "        # cv2.rectangle(image, (x-padding, y-padding), (x+w+padding, y+h+padding),\n",
        "                    # (0, 0, 255), 2)\n",
        "        # print('Face: ',x,y,w,h)\n",
        "        face = image[y-padding:y + h+padding, x-padding:x + w+padding]\n",
        "        # # face_grey = gray[y-padding:y + h+padding, x-padding:x + w+padding]\n",
        "\n",
        "        # protect against dodgy images\n",
        "        if face.shape[0]==0 or face.shape[1]==0: continue\n",
        "        # cv2.imshow(\"face\", face)\n",
        "        # cv2.waitKey(0) \n",
        "        # cv2.destroyAllWindows() \n",
        "\n",
        "        # print('**** comparing --', x,y,w,h)\n",
        "        unknown_image = face#face_recognition.load_image_file(r\"C:\\Users\\jopla\\Projects\\face_extractor\\datasets\\daniel_craig\\daniel_craig_0012.jpg\")\n",
        "        unknown_image = cv2.cvtColor(unknown_image, cv2.COLOR_BGR2RGB)\n",
        "        unknown_image = np.array(Image.fromarray(unknown_image))\n",
        "        unknown_encodings = face_recognition.face_encodings(unknown_image)\n",
        "        if len(unknown_encodings):\n",
        "            results = face_recognition.compare_faces(encodings, unknown_encodings[0])\n",
        "            print(results)\n",
        "            match_count = results.count(True)\n",
        "            print('Found', match_count, 'matche(s) !')\n",
        "            required_matches =  2# @param int\n",
        "            if match_count >= required_matches:\n",
        "                cv2.imwrite(os.path.join(out,out_prexix+str(count).zfill(6)+'.jpg'), face)\n",
        "                # preview = cv2.circle(face, (50, 50), 25, (0, 255, 0), 25)\n",
        "                # preview = cv2.rectangle(image, (x-padding,y-padding), (x+w+padding,y+h+padding), (0,255,0), 20)\n",
        "                # cv2.imshow(imshowname, image_resize(preview, height = 800))\n",
        "                # cv2.waitKey(1)\n",
        "            else:\n",
        "                # preview = cv2.rectangle(image, (x-padding,y-padding), (x+w+padding,y+h+padding), (0,0,255), 20)\n",
        "                # cv2.imshow(imshowname, image_resize(preview, height = 800))\n",
        "                # cv2.waitKey(1)\n",
        "                pass\n",
        "        else:\n",
        "            print('No encodings found')\n",
        "            pass\n",
        "\n",
        "    count += 1\n",
        "    if limit_frames != -1:\n",
        "      if count > (start_offset+limit_frames): break\n",
        "    # if count>50: break\n",
        "\n",
        "# clean up window when done\n",
        "# cv2.destroyAllWindows()"
      ],
      "metadata": {
        "id": "zfwhU-RO1dir"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title ZIP Result\n",
        "zip_dir, out_name = os.path.split(out)\n",
        "zip_path = os.path.join(zip_dir, out_name.replace(' ','')+'.zip')\n",
        "print('Inflating ', out_name, ' ...', )\n",
        "cmd = f\"zip -r {zip_path} {out}\"\n",
        "os.system(cmd)\n",
        "print('Find in Drive =>', zip_path)\n"
      ],
      "metadata": {
        "id": "8VAY0x_2RrEP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title The ZIP already lives in your Drive, will be faster to download it there. Alterntively you can download it here as well.\n",
        "from google.colab import files\n",
        "files.download(zip_path)"
      ],
      "metadata": {
        "id": "qx-Q2nwTTBb2"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}