face shape feature (2).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3a385432",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "import sys\n",
    "import os\n",
    "import csv\n",
    "import dlib\n",
    "import scipy\n",
    "from scipy import ndimage\n",
    "from skimage import measure, io, img_as_ubyte\n",
    "import matplotlib.pyplot as plt\n",
    "from skimage.color import label2rgb, rgb2gray\n",
    "import numpy as np\n",
    "import glob\n",
    "import pandas as pd\n",
    "from sklearn.cluster import KMeans #for clusterin\n",
    "from os import listdir\n",
    "from os.path import isfile, join\n",
    "from imblearn.over_sampling import SMOTE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5a1d4cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np  \n",
    "import cv2  \n",
    "import dlib  \n",
    "import matplotlib.pyplot as plt\n",
    "import pathlib\n",
    "from pathlib import Path\n",
    "import os\n",
    "import imutils\n",
    "import math\n",
    "\n",
    "def get_norm(image,x1,y1,x2,y2):\n",
    "    x = (int(image[x1][y1][0])-int(image[x2][y2][0]))**2\n",
    "    y = (int(image[x1][y1][1])-int(image[x2][y2][1]))**2\n",
    "    z = (int(image[x1][y1][2])-int(image[x2][y2][2]))**2\n",
    "    norm = x + y + z\n",
    "    return norm\n",
    "\n",
    "def get_min(image,x1,y1):\n",
    "    x = int(image[x1][y1][0])\n",
    "    y = int(image[x1][y1][1])\n",
    "    z = int(image[x1][y1][2])\n",
    "    return np.min([x,y,z])\n",
    "\n",
    "def get_color(image,x,y,gray):\n",
    "    if gray == 1: image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "    return np.min(image[y,x])\n",
    "    \n",
    "def get_lum(image,x,y,w,h,k,gray):\n",
    "    if gray == 1:\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "    i1 = range(int(-w/2),int(w/2))\n",
    "    j1 = range(0,h)\n",
    "    lumar = np.zeros((len(i1),len(j1)))\n",
    "    for i in i1:\n",
    "        for j in j1:\n",
    "            lum = np.min(image[y+k*h,x+i])\n",
    "            lumar[i][j] = lum\n",
    "    \n",
    "    return np.min(lumar)\n",
    "\n",
    "def get_ave_down(image,x,y,h,w):\n",
    "    ave = np.min(image[x-w:x+w,y-h:y])\n",
    "    return int(ave)\n",
    "def get_ave_up(image,x,y,h,w):\n",
    "    ave = np.max(image[x-w:x+w,y:y+h])\n",
    "    return int(ave)\n",
    "\n",
    "def d(landmarks,index1,index2):\n",
    "#get distance between i1 and i2\n",
    "    x1 = landmarks[int(index1)][0]\n",
    "    y1 = landmarks[int(index1)][1]\n",
    "    x2 = landmarks[int(index2)][0]\n",
    "    y2 = landmarks[int(index2)][1]\n",
    "    x_diff = (x1 - x2)**2\n",
    "    y_diff = (y1 - y2)**2\n",
    "    dist = math.sqrt(x_diff + y_diff)\n",
    "    return dist\n",
    "\n",
    "def q(landmarks,index1,index2):\n",
    "#get angle between a i1 and i2\n",
    "    x1 = landmarks[int(index1)][0]\n",
    "    y1 = landmarks[int(index1)][1]\n",
    "    x2 = landmarks[int(index2)][0]\n",
    "    y2 = landmarks[int(index2)][1]\n",
    "    \n",
    "    x_diff = float(x1 - x2)\n",
    "    if (y1 == y2): y_diff = 0.1\n",
    "    if (y1 < y2): y_diff = float(np.absolute(y1 - y2))\n",
    "    if (y1 > y2):\n",
    "        y_diff = 0.1\n",
    "    \n",
    "        print(\"Error: Facial feature located below chin.\")\n",
    "    \n",
    "    return np.absolute(math.atan(x_diff/y_diff))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d77710eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "b=[]\n",
    "def features(image, faceCascade):\n",
    "    global data    \n",
    "    faces = faceCascade.detectMultiScale(image, \n",
    "                                         scaleFactor = 1.1, #1.1 \n",
    "                                         minNeighbors = 9, \n",
    "                                         minSize = (30, 30), \n",
    "                                         flags = cv2.CASCADE_SCALE_IMAGE  ) \n",
    "    for (x, y, w, h) in faces:\n",
    "        y=int(0.95*y)\n",
    "        h=int(1.05*h)\n",
    "        cv2.rectangle(image, (x, y), (x + w, y + h), (255, 255, 255), 2)\n",
    "        dlib_rect = dlib.rectangle(int(x), int(0.95*y), int(x + w), int(y + 1.05*h))\n",
    "        detected_landmarks = predictor(image, dlib_rect).parts()\n",
    "        landmarks = np.matrix([[p.x, p.y] for p in detected_landmarks]) \n",
    "        image_copy = image.copy() \n",
    "        for idx, point in enumerate(landmarks): \n",
    "            pos = (point[0, 0], point[0, 1])\n",
    "            cv2.circle(image_copy, pos, 3, color=(255, 153, 0))\n",
    "            p27 = (landmarks[27][0,0],landmarks[27][0,1])\n",
    "            x = p27[0]\n",
    "            y1 = p27[1]\n",
    "            gray = 0\n",
    "            diff = get_lum(image,x,y1,8,1,-1,gray)\n",
    "                #print(diff)\n",
    "            limit = diff-5\n",
    "                \n",
    "            while (diff > limit):\n",
    "                    y1 = int(y1 - 1)\n",
    "                    diff = get_lum(image,x,y1,6,1,-1,gray)\n",
    "            cv2.circle(image_copy, (x,y1), 3, color=(255, 153, 0))\n",
    "            plt.imshow(cv2.cvtColor(image_copy, cv2.COLOR_BGR2RGB))\n",
    "            cv2.imwrite(\"agreene.jpg\", image_copy)\n",
    "                #plt.show()\n",
    "            cv2.waitKey(0)\n",
    "            lmark = landmarks.tolist()\n",
    "            p68 = ((x,y1))\n",
    "            lmark.append(p68)\n",
    "            g=[]\n",
    "            h=[]\n",
    "                \n",
    "            fwidth = d(lmark,0,16)\n",
    "            fheight = d(lmark,8,68)\n",
    "            c=(fheight/fwidth)\n",
    "            jwidth = d(lmark,4,12)\n",
    "            j=(jwidth/fwidth)\n",
    "               \n",
    "            hchinmouth = d(lmark,57,8)\n",
    "            e=(hchinmouth/fwidth)\n",
    "            ref = q(lmark,27,8)\n",
    "            f=ref\n",
    "            for k in range(0,17):\n",
    "              if k != 8:\n",
    "               theta = q(lmark,k,8)\n",
    "               g.append(theta)\n",
    "            x=np.array(g)\n",
    "            for k in range(1,8):\n",
    "              dist = d(lmark,k,16-k)\n",
    "              h.append(dist/fwidth)\n",
    "            y=np.array(h)\n",
    "            z=np.concatenate([x,y])\n",
    "            #k=[label_2,c,j,e,f]\n",
    "            \n",
    "            #feature=np.concatenate([k,z])\n",
    "        \n",
    "                \n",
    "        feature=[diff,fwidth, fheight,c,jwidth,j,hchinmouth,e,ref]   # dfmaster = pd.concat( df_t,   data)\n",
    "        data_1=np.concatenate([feature,z])\n",
    "        data=data_1.tolist()\n",
    "        #print(data)\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8e547b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data ='E:/projects/Face shape classification/spyder/data/crop img/*'\n",
    "faceCascade =  cv2.CascadeClassifier('C:/Users/2109902/My program/face_feature_Randomforest/haarcascade_frontalface_default.xml')\n",
    "predictor_path= 'C:/Users/2109902/My program/face_feature_Randomforest/shape_predictor_68_face_landmarks.dat'\n",
    "  \n",
    "predictor = dlib.shape_predictor(predictor_path) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b863cbc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "SIZE=224\n",
    "\n",
    "train_images=[]\n",
    "train_labels=[]\n",
    "feature_train1=[]\n",
    "for directory_path in glob.glob(train_data):\n",
    "    label_1=directory_path.split(\"\\\\\")[-1]\n",
    "    print(label_1)\n",
    "    for img_path in glob.glob(os.path.join(directory_path, \"*.jpg\")):\n",
    "        \n",
    "     \n",
    "        img = cv2.imread(img_path, cv2.IMREAD_COLOR)       \n",
    "        img = cv2.resize(img, (SIZE, SIZE))\n",
    "        img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)\n",
    "        plt.imshow(img)\n",
    "        features_1 = features(img ,faceCascade)\n",
    "        print(label_1)\n",
    "        face= faceCascade.detectMultiScale(img, 1.01, 9,minSize=(30,30),flags=cv2.CASCADE_SCALE_IMAGE)\n",
    "      \n",
    "        for (x,y,w,h) in face:\n",
    "          y=int(0.95*y)\n",
    "          h=int(1.05*h)\n",
    "        images=img[x:x+w, y:y+h]\n",
    "        images = cv2.resize(images, (SIZE, SIZE))\n",
    "        train_images.append(images)\n",
    "        feature_train1.append(features_1)       #Train _Image _features\n",
    "        train_labels.append( label_1) \n",
    "        # Train labels\n",
    "        #images_1=images_1.tolist()\n",
    "             # Train Images\n",
    "\n",
    "\n",
    "train_label=np.array(train_labels)\n",
    "train_images_1=np.array(train_images) \n",
    "feature_train1=np.array(feature_train1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f85d4fea",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}