colorful_python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * Serving Flask app \"__main__\" (lazy loading)\n",
      " * Environment: production\n",
      "   WARNING: This is a development server. Do not use it in a production deployment.\n",
      "   Use a production WSGI server instead.\n",
      " * Debug mode: off\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)\n",
      "<ipython-input-2-0dfb8a15675d>:10: DeprecationWarning: The binary mode of fromstring is deprecated, as it behaves surprisingly on unicode inputs. Use frombuffer instead\n",
      "  encoded_img = np.fromstring(binary_decode, dtype = np.uint8)\n",
      "127.0.0.1 - - [18/Aug/2022 16:34:28] \"\u001b[37mPOST /test/personalcolor HTTP/1.1\u001b[0m\" 200 -\n"
     ]
    }
   ],
   "source": [
    "# 이미지 저장하는 코드 (imwrite) 검색해서 주석처리하고 배포\n",
    "# 카메라 촬영시 가로로 이미지가 올 수 있음 -> 세로로 돌리기\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "@app.route('/test/personalcolor', methods=['POST'])\n",
    "def hello():\n",
    "    binary_decode = base64.b64decode(request.get_json()[\"binary\"]) # image binary \n",
    "    \n",
    "    encoded_img = np.fromstring(binary_decode, dtype = np.uint8)\n",
    "    img_origin = cv2.imdecode(encoded_img, cv2.IMREAD_COLOR) # image\n",
    "    \n",
    "    resultimg_url = 'img/' + 'test_rotate' + '.jpg'\n",
    "    cv2.imwrite(resultimg_url, np.float32(img_origin))\n",
    "    \n",
    "    return \"롱스톤\"\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    app.run(host=\"0.0.0.0\", port=5000, debug=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * Serving Flask app \"__main__\" (lazy loading)\n",
      " * Environment: production\n",
      "   WARNING: This is a development server. Do not use it in a production deployment.\n",
      "   Use a production WSGI server instead.\n",
      " * Debug mode: off\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)\n",
      "<ipython-input-34-318de7d74eca>:10: DeprecationWarning: The binary mode of fromstring is deprecated, as it behaves surprisingly on unicode inputs. Use frombuffer instead\n",
      "  encoded_img = np.fromstring(binary_decode, dtype = np.uint8)\n",
      "127.0.0.1 - - [06/Aug/2022 01:06:02] \"\u001b[37mPOST /test/personalcolor HTTP/1.1\u001b[0m\" 200 -\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "img_hair ;  [70.37317448116836, 51.552315526518086, 47.29662279016143]\n",
      "img_eye ;  [57.305555555544935, 44.91666666665835, 45.643518518510064]\n",
      "season ;  [63.839365018356645, 48.234491096588215, 46.47007065433574]\n",
      "personal ;  [198.9794403710907, 162.78003890468344, 145.715157863235]\n",
      "personal_hex ;  c6a291\n",
      "season ;  [63.839365018356645, 48.234491096588215, 46.47007065433574]\n",
      "season_hex ;  3f302e\n",
      "result :  가을웜톤\n"
     ]
    }
   ],
   "source": [
    "# 이미지 저장하는 코드 (imwrite) 검색해서 주석처리하고 배포\n",
    "# 카메라 촬영시 가로로 이미지가 올 수 있음 -> 세로로 돌리기\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "@app.route('/test/personalcolor', methods=['POST'])\n",
    "def hello():\n",
    "    binary_decode = base64.b64decode(request.get_json()[\"binary\"]) # image binary \n",
    "\n",
    "    encoded_img = np.fromstring(binary_decode, dtype = np.uint8)\n",
    "    img_origin = cv2.imdecode(encoded_img, cv2.IMREAD_COLOR) # image\n",
    "    \n",
    "    res = getfacialPointsJsonInKakaoAPI(binary_decode)\n",
    "    \n",
    "    img_personal = getFaceImg(img_origin.copy(), res)\n",
    "    avg_color_personal = getImgAvg (img_personal)\n",
    "    personal = rgb2lab (avg_color_personal)\n",
    "    \n",
    "    personal_low = [personal[0]-50, personal[1], personal[2]]\n",
    "    personal_high = [personal[0]+50, personal[1], personal[2]]\n",
    "    low = lab2rgb(personal_low)\n",
    "    high = lab2rgb(personal_high)\n",
    "    \n",
    "    img_cut = cutImg_darkHair(img_origin.copy(), res, personal)\n",
    "    img_hair = cutBg_darkHair(img_cut)\n",
    "    avg_color_hair = getImgAvg (img_hair)\n",
    "    \n",
    "    img_eye = getEyes(img_origin.copy(), res)\n",
    "    img_eye= cutBg_darkHair(img_eye)\n",
    "    avg_color_eye = getImgAvg (img_eye)\n",
    "    \n",
    "    avg_color_season = [0, 0, 0]\n",
    "    avg_color_season[0] = (avg_color_hair[0] + avg_color_eye[0]) / 2\n",
    "    avg_color_season[1] = (avg_color_hair[1] + avg_color_eye[1]) / 2\n",
    "    avg_color_season[2] = (avg_color_hair[2] + avg_color_eye[2]) / 2\n",
    "    \n",
    "    season = rgb2lab (avg_color_season)\n",
    "    \n",
    "    print('img_hair ; ', avg_color_hair)\n",
    "    print('img_eye ; ', avg_color_eye)\n",
    "    print('season ; ', avg_color_season)\n",
    "    \n",
    "    result = getPersonalColor(personal, season)\n",
    "    \n",
    "    print('personal ; ', avg_color_personal)\n",
    "    print('personal_hex ; ', rgb2hex(avg_color_personal))\n",
    "    print('season ; ', avg_color_season)\n",
    "    print('season_hex ; ', rgb2hex(avg_color_season))\n",
    "    print('result : ', result)\n",
    "        \n",
    "    resultimg_url = 'img/' + 'personal' + '_result.jpg'\n",
    "    cv2.imwrite(resultimg_url, np.float32(img_personal))\n",
    "    \n",
    "    resultimg_url = 'img/' + 'hair' + '_result.jpg'\n",
    "    cv2.imwrite(resultimg_url, np.float32(img_hair))\n",
    "    \n",
    "    resultimg_url = 'img/' + 'eye' + '_result.jpg'\n",
    "    cv2.imwrite(resultimg_url, np.float32(img_eye))\n",
    "        \n",
    "    resultimg_url = 'img/' + 'origin' + '_result.jpg'\n",
    "    cv2.imwrite(resultimg_url, np.float32(img_origin))\n",
    "\n",
    "    return result\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    app.run(host=\"0.0.0.0\", port=5000, debug=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################################################\n",
    "# rgb2hex\n",
    "# param : color(list index = 3)\n",
    "# return : color_hex(list index = 3)\n",
    "##################################################################\n",
    "\n",
    "def rgb2hex(color):\n",
    "    color_hex_list = []\n",
    "\n",
    "    color_hex_list.append(hex(int(color[0])))\n",
    "    color_hex_list.append(hex(int(color[1])))\n",
    "    color_hex_list.append(hex(int(color[2])))\n",
    "    \n",
    "    color_hex = color_hex_list[0][-2:] + color_hex_list[1][-2:] + color_hex_list[2][-2:]\n",
    "    return color_hex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################################################\n",
    "# getEyes\n",
    "# param : img(user image jpg), res(kakao api response)\n",
    "# return : result_img / <img>\n",
    "##################################################################\n",
    "\n",
    "def getEyes(img, res):\n",
    "    json_facial_points = json.loads(str(res.json()['result']['faces'])[1:-1].replace('\\'', '\\\"'))['facial_points']\n",
    "    h_o, w_o, c = img.shape\n",
    "    polygon_face = []\n",
    "    \n",
    "    for position in json_facial_points['left_eye']:\n",
    "        point = (int(position[0]*w_o), int(position[1]*h_o))\n",
    "        polygon_face.append(point)\n",
    "\n",
    "    # convert to numpy (for convenience)\n",
    "    result_img = np.asarray(img)\n",
    "\n",
    "    # create new image (\"1-bit pixels, black and white\", (width, height), \"default color\")\n",
    "    mask_img = Image.new('1', (result_img.shape[1], result_img.shape[0]), 0)\n",
    "\n",
    "    ImageDraw.Draw(mask_img).polygon(polygon_face, outline=1, fill=1)\n",
    "    mask = np.array(mask_img)\n",
    "\n",
    "    # assemble new image (uint8: 0-255)\n",
    "    new_img_array = np.empty(result_img.shape, dtype='uint8')\n",
    "\n",
    "    # copy color values (RGB)\n",
    "    new_img_array[:,:,:3] = result_img[:,:,:3]\n",
    "\n",
    "    # filtering image by mask\n",
    "    new_img_array[:,:,0] = new_img_array[:,:,0] * mask\n",
    "    new_img_array[:,:,1] = new_img_array[:,:,1] * mask\n",
    "    new_img_array[:,:,2] = new_img_array[:,:,2] * mask\n",
    "\n",
    "    # back to Image from numpy\n",
    "#     result_img = Image.fromarray(new_img_array, \"RGB\")\n",
    "#     result_img = np.float32(result_img)\n",
    "\n",
    "#     resultimg_url = 'img/' + 'eye' + '_result.jpg'\n",
    "#     cv2.imwrite(resultimg_url, (result_img))\n",
    "    \n",
    "    \n",
    "    h_o, w_o, c = result_img.shape\n",
    "    for position_x in range(0, w_o):\n",
    "        for position_y in range(0, h_o):\n",
    "            condition_r = result_img[position_y, position_x][0] < 70\n",
    "            condition_g = result_img[position_y, position_x][1] < 70\n",
    "            condition_b = result_img[position_y, position_x][2] < 70\n",
    "            if (condition_r == False and condition_g == False and condition_b == False):\n",
    "                result_img[position_y, position_x] = [0, 0, 0]\n",
    "\n",
    "    return np.float32(result_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2 as cv2\n",
    "import numpy as np\n",
    "from PIL import Image, ImageDraw\n",
    "\n",
    "from sklearn.cluster import KMeans\n",
    "# import matplotlib.pyplot as plt\n",
    "\n",
    "import json\n",
    "import requests\n",
    "\n",
    "from flask import Flask, request, jsonify\n",
    "import base64\n",
    "\n",
    "import logging\n",
    "import sys\n",
    "\n",
    "from PIL import Image\n",
    "\n",
    "from colormath.color_objects import sRGBColor, LabColor\n",
    "from colormath.color_conversions import convert_color\n",
    "\n",
    "#jpg\n",
    "\n",
    "##################################################################\n",
    "# getFaceImg\n",
    "# param : img(user image jpg), res(kakao api response)\n",
    "# return : result_img / <img>\n",
    "##################################################################\n",
    "\n",
    "def getFaceImg(img, res):\n",
    "    result_img = img.copy()\n",
    "\n",
    "    h_o, w_o, c = result_img.shape\n",
    "\n",
    "    json_faces = json.loads(str(res.json()['result']['faces'])[1:-1].replace('\\'', '\\\"'))\n",
    "\n",
    "    x = json_faces['x']\n",
    "    y = json_faces['y']\n",
    "    w = json_faces['w']\n",
    "    h = json_faces['h']\n",
    "\n",
    "    json_facial_points = json_faces['facial_points']\n",
    "\n",
    "    erase_object(result_img, json_facial_points['left_eyebrow'], w_o, h_o, (0, 0, 0))\n",
    "    erase_object(result_img, json_facial_points['right_eyebrow'], w_o, h_o, (0, 0, 0))\n",
    "    erase_object(result_img, json_facial_points['left_eye'], w_o, h_o, (0, 0, 0))\n",
    "    erase_object(result_img, json_facial_points['right_eye'], w_o, h_o, (0, 0, 0))\n",
    "    erase_object(result_img, json_facial_points['lip'], w_o, h_o, (0, 0, 0))\n",
    "    # erase_object(result_img, , w_o, h_o)\n",
    "\n",
    "    polygon_face = []\n",
    "    # polygon_face.append(json_facial_points['right_eyebrow'])\n",
    "    # polygon_face.append(json_facial_points['left_eyebrow'])\n",
    "\n",
    "\n",
    "    for position in json_facial_points['jaw']:\n",
    "        point = (int(position[0]*w_o), int(position[1]*h_o))\n",
    "        polygon_face.append(point)\n",
    "\n",
    "    for position in json_facial_points['right_eyebrow']:\n",
    "        point = (int(position[0]*w_o), int(position[1]*h_o))\n",
    "        polygon_face.append(point)\n",
    "\n",
    "    for position in json_facial_points['left_eyebrow']:\n",
    "        point = (int(position[0]*w_o), int(position[1]*h_o))\n",
    "        polygon_face.append(point)\n",
    "\n",
    "\n",
    "#     result_img = np.asarray(result_img)\n",
    "\n",
    "    # convert to numpy (for convenience)\n",
    "    result_img = np.asarray(result_img)\n",
    "\n",
    "    # create new image (\"1-bit pixels, black and white\", (width, height), \"default color\")\n",
    "    mask_img = Image.new('1', (result_img.shape[1], result_img.shape[0]), 0)\n",
    "\n",
    "    ImageDraw.Draw(mask_img).polygon(polygon_face, outline=1, fill=1)\n",
    "    mask = np.array(mask_img)\n",
    "\n",
    "    # assemble new image (uint8: 0-255)\n",
    "    new_img_array = np.empty(result_img.shape, dtype='uint8')\n",
    "\n",
    "    # copy color values (RGB)\n",
    "    new_img_array[:,:,:3] = result_img[:,:,:3]\n",
    "\n",
    "    # filtering image by mask\n",
    "    new_img_array[:,:,0] = new_img_array[:,:,0] * mask\n",
    "    new_img_array[:,:,1] = new_img_array[:,:,1] * mask\n",
    "    new_img_array[:,:,2] = new_img_array[:,:,2] * mask\n",
    "\n",
    "    # back to Image from numpy\n",
    "    result_img = Image.fromarray(new_img_array, \"RGB\")\n",
    "\n",
    "#     resultimg_url = 'img/' + 'deviceTest' + '_result.jpg'\n",
    "#     cv2.imwrite(resultimg_url, np.float32(result_img))\n",
    "\n",
    "    return np.float32(result_img)\n",
    "\n",
    "def erase_object(result_img, list, w_o, h_o, rect_color): # 이미지, 원하는 좌표가 들어간 배열, 이미지 크기\n",
    "    x_left = w_o\n",
    "    x_right = 0\n",
    "    y_up = h_o\n",
    "    y_down = 0\n",
    "\n",
    "    for x_temp, y_temp in list:\n",
    "        y_temp = (int)(y_temp*h_o)\n",
    "        x_temp = (int)(x_temp*w_o)\n",
    "        if x_left > x_temp:\n",
    "            x_left = x_temp\n",
    "        if x_right < x_temp:\n",
    "            x_right = x_temp\n",
    "        if y_up > y_temp:\n",
    "            y_up = y_temp\n",
    "        if y_down < y_temp:\n",
    "            y_down = y_temp\n",
    "\n",
    "    cv2.rectangle(result_img, (x_left, y_up), (x_right, y_down), rect_color, -1)\n",
    "    \n",
    "    \n",
    "##################################################################\n",
    "# kakao API로 이미지 얼굴 특징 좌표 값 받아오기 -> 파라미터는 바이너리 파일\n",
    "# param : image(user image_binary)\n",
    "# return : facial_points_json / <class 'str'>\n",
    "\n",
    "# jaw 검출된 턱선의 17개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "# right_eyebrow 검출된 오른쪽 눈썹의 5개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "# left_eyebrow 검출된 왼쪽 눈썹의 5개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "# nose 검출된 코의 9개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "# right_eye 검출된 오른쪽 눈의 6개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "# left_eye 검출된 왼쪽 눈의 6개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "# lip 검출된 입술의 20개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "##################################################################\n",
    "\n",
    "\n",
    "def getfacialPointsJsonInKakaoAPI(image):\n",
    "    url_kakaoAPI = \"dapi.kakao.com/v2/vision/face/detect\"\n",
    "\n",
    "    # headers = {'Content-Type': 'application/json; chearset=utf-8'}\n",
    "\n",
    "    appkey = \"cd01a673937be048c7a932050faed168\"\n",
    "\n",
    "    headers = {\n",
    "        # requests won't add a boundary if this header is set when you pass files=\n",
    "        # 'Content-Type': 'multipart/form-data',\n",
    "        'Authorization': 'KakaoAK cd01a673937be048c7a932050faed168',\n",
    "    }\n",
    "\n",
    "    files = {\n",
    "        'image': image,\n",
    "    }\n",
    "\n",
    "    res = requests.post('https://dapi.kakao.com/v2/vision/face/detect', headers=headers, files=files)\n",
    "    \n",
    "    return res\n",
    "\n",
    "\n",
    "\n",
    "##################################################################\n",
    "# getImgAvg \n",
    "# param : image (전처리 완료된 유저 이미지)\n",
    "# return : [R, G, B] / <class 'list'>\n",
    "##################################################################\n",
    "\n",
    "\n",
    "# 진또배기\n",
    "\n",
    "# image = cv2.imread(img_url)\n",
    "\n",
    "def getImgAvg ( image ) :\n",
    "\n",
    "    \n",
    "    # imge_binary To image(npArray)\n",
    "    \n",
    "    # 채널을 BGR -> RGB로 변경\n",
    "    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "    image = image.reshape((image.shape[0] * image.shape[1], 3)) # height, width 통합\n",
    "\n",
    "    count_color = 10\n",
    "    clt = KMeans(n_clusters = count_color)\n",
    "    clt.fit(image)\n",
    "\n",
    "    colorList = []\n",
    "    numLabels = np.arange(0, len(np.unique(clt.labels_)) + 1)\n",
    "    (hist, _) = np.histogram(clt.labels_, bins=numLabels)\n",
    "\n",
    "    # normalize the histogram, such that it sums to one\n",
    "    hist = hist.astype(\"float\")\n",
    "    hist /= hist.sum()\n",
    "    \n",
    "    colorRatioList = list(hist)\n",
    "    for (colorRatio, color) in zip(colorRatioList, clt.cluster_centers_):\n",
    "        colorList.append(color.astype(np.int64))\n",
    "      # print(color, colorRatio)\n",
    "\n",
    "\n",
    "    avg_color = [0, 0, 0]\n",
    "    colorRatio_std = -1\n",
    "    for (color, colorRatio) in zip(colorList, colorRatioList):\n",
    "        if (color[0] != 0 and color[1] != 0 and color[2] != 0 ): #제거된 배경은 제외\n",
    "#             color[0] != 0 and color[1] != 0 and color[2] != 0\n",
    "#             print(color[0], \",  \", color[1], \",  \", color[2], \" -> \", colorRatio)\n",
    "            avg_color[0] += color[0] * colorRatio * 100\n",
    "            avg_color[1] += color[1] * colorRatio * 100\n",
    "            avg_color[2] += color[2] * colorRatio * 100\n",
    "        else:\n",
    "            colorRatio_std = colorRatio * 100\n",
    "\n",
    "    avg_color[0] = avg_color[0]/(100-colorRatio_std)\n",
    "    avg_color[1] = avg_color[1]/(100-colorRatio_std)\n",
    "    avg_color[2] = avg_color[2]/(100-colorRatio_std)\n",
    "    \n",
    "    return avg_color\n",
    "\n",
    "##################################################################\n",
    "# cutImg_darkHair\n",
    "# param : img(유저 이미지 기본), res(kakao api response), low(user face low color - rgb), high(user face high color)\n",
    "# return : img / <class 'img'>\n",
    "##################################################################\n",
    "\n",
    "def cutImg_darkHair(img, res, personal):\n",
    "    \n",
    "    personal_low = [personal[0]-50, personal[1], personal[2]]\n",
    "    personal_high = [personal[0]+50, personal[1], personal[2]]\n",
    "    low = lab2rgb(personal_low)\n",
    "    high = lab2rgb(personal_high)\n",
    "    \n",
    "    \n",
    "    json_faces = json.loads(str(res.json()['result']['faces'])[1:-1].replace('\\'', '\\\"'))\n",
    "\n",
    "    h_o, w_o, c = img.shape\n",
    "    \n",
    "    x = json_faces['x']\n",
    "    y = json_faces['y']\n",
    "    w = json_faces['w']\n",
    "    h = json_faces['h']\n",
    "    \n",
    "    \n",
    "    json_facial_points = json_faces['facial_points']\n",
    "\n",
    "    erase_object(img, json_facial_points['left_eyebrow'], w_o, h_o, (255, 255, 255))\n",
    "    erase_object(img, json_facial_points['right_eyebrow'], w_o, h_o, (255, 255, 255))\n",
    "    erase_object(img, json_facial_points['left_eye'], w_o, h_o, (255, 255, 255))\n",
    "    erase_object(img, json_facial_points['right_eye'], w_o, h_o, (255, 255, 255))\n",
    "    erase_object(img, json_facial_points['lip'], w_o, h_o, (255, 255, 255))\n",
    "    erase_object(img, json_facial_points['nose'], w_o, h_o, (255, 255, 255))\n",
    "\n",
    "    img = img[0:int(h*h_o) + int(y*h_o), 0:w_o]\n",
    "    h_o, w_o, c = img.shape\n",
    "#     img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)\n",
    "    \n",
    "    img_cutHead = cv2.inRange(img, (low[0], low[1], low[2]), (high[0], high[2], high[2])) # 이거 기준 하얀색은 제거\n",
    "    \n",
    "    resultimg_url = 'img/' + 'test_cuthead' + '_result.jpg'\n",
    "    cv2.imwrite(resultimg_url, np.float32(img_cutHead))\n",
    "    \n",
    "#     print('img : ', type(img))\n",
    "#     print('img_cut : ', type(img_cutHead))\n",
    "    \n",
    "\n",
    "    for position_x in range(0, w_o):\n",
    "        for position_y in range(0, h_o):\n",
    "#             print(img_cutHead[position_y,position_x])\n",
    "            if img_cutHead[position_y, position_x] == 255:\n",
    "                img[position_y, position_x][0] = 0\n",
    "                img[position_y, position_x][1] = 0\n",
    "                img[position_y, position_x][2] = 0\n",
    "\n",
    "\n",
    "#     resultimg_url = 'img/' + 'test_cutimg' + '_result.jpg'\n",
    "#     cv2.imwrite(resultimg_url, np.float32(img))\n",
    "    \n",
    "    return img\n",
    "\n",
    "\n",
    "##################################################################\n",
    "# cut img Background \n",
    "# param : img(전처리된 유저 이미지)\n",
    "# return : result / <class 'np.array'(img)>\n",
    "##################################################################\n",
    "\n",
    "\n",
    "def cutBg_darkHair(img):\n",
    "    # 변환 graky\n",
    "    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "    # 임계값 조절\n",
    "    mask = cv2.threshold(gray, 230, 255, cv2.THRESH_BINARY)[1]\n",
    "\n",
    "    # mask\n",
    "    mask = 255 - mask\n",
    "\n",
    "    # morphology 적용\n",
    "    # borderconstant 사용\n",
    "    kernel = np.ones((3,3), np.uint8)\n",
    "    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)\n",
    "    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)\n",
    "\n",
    "    # anti-alias the mask\n",
    "    # blur alpha channel\n",
    "    mask = cv2.GaussianBlur(mask, (0,0), sigmaX=2, sigmaY=2, borderType = cv2.BORDER_DEFAULT)\n",
    "\n",
    "    # linear stretch so that 127.5 goes to 0, but 255 stays 255\n",
    "    mask = (2*(mask.astype(np.float32))-255.0).clip(0,255).astype(np.uint8)\n",
    "\n",
    "    # put mask into alpha channel\n",
    "    result = img.copy()\n",
    "    result = cv2.cvtColor(result, cv2.COLOR_BGR2BGRA)\n",
    "    result[:, :, 3] = mask\n",
    "    \n",
    "#     resultimg_url = 'img/' + 'test' + '_result.png'\n",
    "#     cv2.imwrite(resultimg_url, (result))\n",
    "\n",
    "    return result\n",
    "\n",
    "\n",
    "##################################################################\n",
    "# RGB to Lab\n",
    "# param : inputColor(RGB list)\n",
    "# return : [L, A, B] / <class 'list'>\n",
    "##################################################################\n",
    "\n",
    "\n",
    "def rgb2lab ( inputColor ) :\n",
    "\n",
    "    num = 0\n",
    "    RGB = [0, 0, 0]\n",
    "\n",
    "    for value in inputColor :\n",
    "        value = float(value) / 255\n",
    "\n",
    "        if value > 0.04045 :\n",
    "            value = ( ( value + 0.055 ) / 1.055 ) ** 2.4\n",
    "        else :\n",
    "            value = value / 12.92\n",
    "\n",
    "        RGB[num] = value * 100\n",
    "        num = num + 1\n",
    "\n",
    "    XYZ = [0, 0, 0,]\n",
    "\n",
    "    X = RGB [0] * 0.4124 + RGB [1] * 0.3576 + RGB [2] * 0.1805\n",
    "    Y = RGB [0] * 0.2126 + RGB [1] * 0.7152 + RGB [2] * 0.0722\n",
    "    Z = RGB [0] * 0.0193 + RGB [1] * 0.1192 + RGB [2] * 0.9505\n",
    "    XYZ[ 0 ] = round( X, 4 )\n",
    "    XYZ[ 1 ] = round( Y, 4 )\n",
    "    XYZ[ 2 ] = round( Z, 4 )\n",
    "\n",
    "    XYZ[ 0 ] = float( XYZ[ 0 ] ) / 95.047         # ref_X =  95.047   Observer= 2°, Illuminant= D65\n",
    "    XYZ[ 1 ] = float( XYZ[ 1 ] ) / 100.0          # ref_Y = 100.000\n",
    "    XYZ[ 2 ] = float( XYZ[ 2 ] ) / 108.883        # ref_Z = 108.883\n",
    "\n",
    "    num = 0\n",
    "    \n",
    "    for value in XYZ :\n",
    "\n",
    "        if value > 0.008856 :\n",
    "            value = value ** ( 0.3333333333333333 )\n",
    "        else :\n",
    "            value = ( 7.787 * value ) + ( 16 / 116 )\n",
    "\n",
    "        XYZ[num] = value\n",
    "        num = num + 1\n",
    "\n",
    "    Lab = [0, 0, 0]\n",
    "\n",
    "    L = ( 116 * XYZ[ 1 ] ) - 16\n",
    "    a = 500 * ( XYZ[ 0 ] - XYZ[ 1 ] )\n",
    "    b = 200 * ( XYZ[ 1 ] - XYZ[ 2 ] )\n",
    "\n",
    "    Lab [ 0 ] = round( L, 4 )\n",
    "    Lab [ 1 ] = round( a, 4 )\n",
    "    Lab [ 2 ] = round( b, 4 )\n",
    "\n",
    "    return Lab\n",
    "\n",
    "\n",
    "\n",
    "##################################################################\n",
    "# Lab to sRGB\n",
    "# param : inputColor(LAB list)\n",
    "# return : [R, G, B] / <class 'list'>\n",
    "##################################################################\n",
    "\n",
    "\n",
    "def lab2rgb ( inputColor ) :\n",
    "    lab = LabColor(inputColor[0], inputColor[1], inputColor[2]) \n",
    "    rgb_ratio = convert_color(lab, sRGBColor)\n",
    "    rgb = [0, 0, 0]\n",
    "    rgb[0] = rgb_ratio.rgb_r * 255\n",
    "    rgb[1] = rgb_ratio.rgb_g * 255\n",
    "    rgb[2] = rgb_ratio.rgb_b * 255\n",
    "    return rgb\n",
    "\n",
    "\n",
    "##################################################################\n",
    "# getPersonalColor\n",
    "# param : personal(RGB list), season(RGB list)\n",
    "# return : \"가을웜톤\" / <class 'String'>\n",
    "##################################################################\n",
    "\n",
    "def getPersonalColor(personal, season):\n",
    "    \n",
    "    result = \"\"\n",
    "    \n",
    "    if(personal[1] > personal[2]):\n",
    "        result += \"쿨톤\"\n",
    "        \n",
    "        if(season[0] > 50):\n",
    "            result = \"겨울\" + result\n",
    "        else:\n",
    "            result = \"여름\" + result\n",
    "            \n",
    "    else:\n",
    "        result += \"웜톤\"\n",
    "        \n",
    "        if(season[0] > 50):\n",
    "            result = \"봄\" + result\n",
    "        else:\n",
    "            result = \"가을\" + result\n",
    "            \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2 as cv2\n",
    "import numpy as np\n",
    "from PIL import Image, ImageDraw\n",
    "\n",
    "from sklearn.cluster import KMeans\n",
    "# import matplotlib.pyplot as plt\n",
    "\n",
    "import json\n",
    "import requests\n",
    "\n",
    "from flask import Flask, request, jsonify\n",
    "import base64\n",
    "\n",
    "import logging\n",
    "import sys\n",
    "\n",
    "from PIL import Image\n",
    "\n",
    "from colormath.color_objects import sRGBColor, LabColor\n",
    "from colormath.color_conversions import convert_color"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#jpg\n",
    "\n",
    "def getFaceImg(img, res):\n",
    "    result_img = img.copy()\n",
    "\n",
    "    h_o, w_o, c = result_img.shape\n",
    "\n",
    "    print('shape : ', w_o, \", \", h_o)\n",
    "\n",
    "    json_faces = json.loads(str(res.json()['result']['faces'])[1:-1].replace('\\'', '\\\"'))\n",
    "\n",
    "    x = json_faces['x']\n",
    "    y = json_faces['y']\n",
    "    w = json_faces['w']\n",
    "    h = json_faces['h']\n",
    "\n",
    "    json_facial_points = json_faces['facial_points']\n",
    "\n",
    "    erase_object(result_img, json_facial_points['left_eyebrow'], w_o, h_o)\n",
    "    erase_object(result_img, json_facial_points['right_eyebrow'], w_o, h_o)\n",
    "    erase_object(result_img, json_facial_points['left_eye'], w_o, h_o)\n",
    "    erase_object(result_img, json_facial_points['right_eye'], w_o, h_o)\n",
    "    erase_object(result_img, json_facial_points['lip'], w_o, h_o)\n",
    "    # erase_object(result_img, , w_o, h_o)\n",
    "\n",
    "    polygon_face = []\n",
    "    # polygon_face.append(json_facial_points['right_eyebrow'])\n",
    "    # polygon_face.append(json_facial_points['left_eyebrow'])\n",
    "\n",
    "\n",
    "    for position in json_facial_points['jaw']:\n",
    "        point = (int(position[0]*w_o), int(position[1]*h_o))\n",
    "        polygon_face.append(point)\n",
    "\n",
    "    for position in json_facial_points['right_eyebrow']:\n",
    "        point = (int(position[0]*w_o), int(position[1]*h_o))\n",
    "        polygon_face.append(point)\n",
    "\n",
    "    for position in json_facial_points['left_eyebrow']:\n",
    "        point = (int(position[0]*w_o), int(position[1]*h_o))\n",
    "        polygon_face.append(point)\n",
    "\n",
    "\n",
    "    result_img = np.asarray(result_img)\n",
    "\n",
    "    # convert to numpy (for convenience)\n",
    "    result_img = np.asarray(result_img)\n",
    "\n",
    "    # create mask\n",
    "    polygon = [(444,203),(623,243),(691,177),(581,26),(482,42)]\n",
    "\n",
    "    # create new image (\"1-bit pixels, black and white\", (width, height), \"default color\")\n",
    "    mask_img = Image.new('1', (result_img.shape[1], result_img.shape[0]), 0)\n",
    "\n",
    "    ImageDraw.Draw(mask_img).polygon(polygon_face, outline=1, fill=1)\n",
    "    mask = np.array(mask_img)\n",
    "\n",
    "    # assemble new image (uint8: 0-255)\n",
    "    new_img_array = np.empty(result_img.shape, dtype='uint8')\n",
    "\n",
    "    # copy color values (RGB)\n",
    "    new_img_array[:,:,:3] = result_img[:,:,:3]\n",
    "\n",
    "    # filtering image by mask\n",
    "    new_img_array[:,:,0] = new_img_array[:,:,0] * mask\n",
    "    new_img_array[:,:,1] = new_img_array[:,:,1] * mask\n",
    "    new_img_array[:,:,2] = new_img_array[:,:,2] * mask\n",
    "\n",
    "    # back to Image from numpy\n",
    "    result_img = Image.fromarray(new_img_array, \"RGB\")\n",
    "\n",
    "#     resultimg_url = 'img/' + 'deviceTest' + '_result.jpg'\n",
    "#     cv2.imwrite(resultimg_url, np.float32(result_img))\n",
    "\n",
    "    return np.float32(result_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def erase_object(result_img, list, w_o, h_o): # 이미지, 원하는 좌표가 들어간 배열, 이미지 크기\n",
    "    x_left = w_o\n",
    "    x_right = 0\n",
    "    y_up = h_o\n",
    "    y_down = 0\n",
    "\n",
    "    for x_temp, y_temp in list:\n",
    "        y_temp = (int)(y_temp*h_o)\n",
    "        x_temp = (int)(x_temp*w_o)\n",
    "        if x_left > x_temp:\n",
    "            x_left = x_temp\n",
    "        if x_right < x_temp:\n",
    "            x_right = x_temp\n",
    "        if y_up > y_temp:\n",
    "            y_up = y_temp\n",
    "        if y_down < y_temp:\n",
    "            y_down = y_temp\n",
    "\n",
    "    cv2.rectangle(result_img, (x_left, y_up), (x_right, y_down), (0, 0, 0), -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################################################\n",
    "# kakao API로 이미지 얼굴 특징 좌표 값 받아오기 -> 파라미터는 바이너리 파일\n",
    "# return : facial_points_json / <class 'str'>\n",
    "\n",
    "# jaw 검출된 턱선의 17개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "# right_eyebrow 검출된 오른쪽 눈썹의 5개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "# left_eyebrow 검출된 왼쪽 눈썹의 5개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "# nose 검출된 코의 9개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "# right_eye 검출된 오른쪽 눈의 6개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "# left_eye 검출된 왼쪽 눈의 6개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "# lip 검출된 입술의 20개의 좌표 배열, 0 ~ 1.0 사이의 (x,y) 값의 배열\n",
    "##################################################################\n",
    "\n",
    "\n",
    "def getfacialPointsJsonInKakaoAPI(image):\n",
    "    url_kakaoAPI = \"dapi.kakao.com/v2/vision/face/detect\"\n",
    "\n",
    "    # headers = {'Content-Type': 'application/json; chearset=utf-8'}\n",
    "\n",
    "    appkey = \"cd01a673937be048c7a932050faed168\"\n",
    "\n",
    "    headers = {\n",
    "        # requests won't add a boundary if this header is set when you pass files=\n",
    "        # 'Content-Type': 'multipart/form-data',\n",
    "        'Authorization': 'KakaoAK cd01a673937be048c7a932050faed168',\n",
    "    }\n",
    "\n",
    "    files = {\n",
    "        'image': image,\n",
    "    }\n",
    "\n",
    "    res = requests.post('https://dapi.kakao.com/v2/vision/face/detect', headers=headers, files=files)\n",
    "    \n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################################################\n",
    "# getImgAvg --> 이미지 cv2로 읽는 건 되는데 api로 이미지 받은 것도 되는지는 모르겠네\n",
    "# --> image로 받는 거 바이너리 파일이니까 진짜 이미지로 변경해주어야함\n",
    "# return : [R, G, B] / <class 'list'>\n",
    "##################################################################\n",
    "\n",
    "\n",
    "# 진또배기\n",
    "\n",
    "# image = cv2.imread(img_url)\n",
    "\n",
    "def getImgAvg ( image ) :\n",
    "\n",
    "    \n",
    "    # imge_binary To image(npArray)\n",
    "    \n",
    "    # 채널을 BGR -> RGB로 변경\n",
    "    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "    image = image.reshape((image.shape[0] * image.shape[1], 3)) # height, width 통합\n",
    "\n",
    "    count_color = 10\n",
    "    clt = KMeans(n_clusters = count_color)\n",
    "    clt.fit(image)\n",
    "\n",
    "    colorList = []\n",
    "    numLabels = np.arange(0, len(np.unique(clt.labels_)) + 1)\n",
    "    (hist, _) = np.histogram(clt.labels_, bins=numLabels)\n",
    "\n",
    "    # normalize the histogram, such that it sums to one\n",
    "    hist = hist.astype(\"float\")\n",
    "    hist /= hist.sum()\n",
    "    \n",
    "    colorRatioList = list(hist)\n",
    "    for (colorRatio, color) in zip(colorRatioList, clt.cluster_centers_):\n",
    "        colorList.append(color.astype(np.int64))\n",
    "      # print(color, colorRatio)\n",
    "\n",
    "\n",
    "    avg_color = [0, 0, 0]\n",
    "    colorRatio_std = -1\n",
    "    for (color, colorRatio) in zip(colorList, colorRatioList):\n",
    "        if(color[0] != 0 and color[1] != 0 and color[2] != 0): #제거된 배경은 제외\n",
    "#             print(color[0], \",  \", color[1], \",  \", color[2], \" -> \", colorRatio)\n",
    "            avg_color[0] += color[0] * colorRatio * 100\n",
    "            avg_color[1] += color[1] * colorRatio * 100\n",
    "            avg_color[2] += color[2] * colorRatio * 100\n",
    "        else:\n",
    "            colorRatio_std = colorRatio * 100\n",
    "\n",
    "    avg_color[0] = avg_color[0]/(100-colorRatio_std)\n",
    "    avg_color[1] = avg_color[1]/(100-colorRatio_std)\n",
    "    avg_color[2] = avg_color[2]/(100-colorRatio_std)\n",
    "    \n",
    "    return avg_color"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cutImg_darkHair(img, res, avg):\n",
    "    json_faces = json.loads(str(res.json()['result']['faces'])[1:-1].replace('\\'', '\\\"'))\n",
    "\n",
    "    h_o, w_o, c = img.shape\n",
    "    \n",
    "    x = json_faces['x']\n",
    "    y = json_faces['y']\n",
    "    w = json_faces['w']\n",
    "    h = json_faces['h']\n",
    "\n",
    "    img = img[0:int(y*h_o), int(x*w_o):int(w*w_o)+int(x*w_o)]\n",
    "    \n",
    "#     img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)\n",
    "    \n",
    "#     img = cv2.inRange(img, (avg[0], avg[1], avg[2]), (avg[0], avg[2], avg[2]))\n",
    "    \n",
    "#     img = cv2.cvtColor(img, cv2.COLOR_HSV2BGR)\n",
    "    \n",
    "#     resultimg_url = 'img/' + 'test_cutdown' + '_result.jpg'\n",
    "#     cv2.imwrite(resultimg_url, np.float32(img))\n",
    "    \n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################################################\n",
    "# cut img Background \n",
    "# return : result / <class 'np.array'(img)>\n",
    "##################################################################\n",
    "\n",
    "\n",
    "def cutBg_darkHair(img):\n",
    "    # 변환 graky\n",
    "    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "    # 임계값 조절\n",
    "    mask = cv2.threshold(gray, 230, 255, cv2.THRESH_BINARY)[1]\n",
    "\n",
    "    # mask\n",
    "    mask = 255 - mask\n",
    "\n",
    "    # morphology 적용\n",
    "    # borderconstant 사용\n",
    "    kernel = np.ones((3,3), np.uint8)\n",
    "    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)\n",
    "    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)\n",
    "\n",
    "    # anti-alias the mask\n",
    "    # blur alpha channel\n",
    "    mask = cv2.GaussianBlur(mask, (0,0), sigmaX=2, sigmaY=2, borderType = cv2.BORDER_DEFAULT)\n",
    "\n",
    "    # linear stretch so that 127.5 goes to 0, but 255 stays 255\n",
    "    mask = (2*(mask.astype(np.float32))-255.0).clip(0,255).astype(np.uint8)\n",
    "\n",
    "    # put mask into alpha channel\n",
    "    result = img.copy()\n",
    "    result = cv2.cvtColor(result, cv2.COLOR_BGR2BGRA)\n",
    "    result[:, :, 3] = mask\n",
    "    \n",
    "#     resultimg_url = 'img/' + 'test' + '_result.png'\n",
    "#     cv2.imwrite(resultimg_url, (result))\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################################################\n",
    "# RGB to Lab\n",
    "# return : [L, A, B] / <class 'list'>\n",
    "##################################################################\n",
    "\n",
    "\n",
    "def rgb2lab ( inputColor ) :\n",
    "\n",
    "   num = 0\n",
    "   RGB = [0, 0, 0]\n",
    "\n",
    "   for value in inputColor :\n",
    "       value = float(value) / 255\n",
    "\n",
    "       if value > 0.04045 :\n",
    "           value = ( ( value + 0.055 ) / 1.055 ) ** 2.4\n",
    "       else :\n",
    "           value = value / 12.92\n",
    "\n",
    "       RGB[num] = value * 100\n",
    "       num = num + 1\n",
    "\n",
    "   XYZ = [0, 0, 0,]\n",
    "\n",
    "   X = RGB [0] * 0.4124 + RGB [1] * 0.3576 + RGB [2] * 0.1805\n",
    "   Y = RGB [0] * 0.2126 + RGB [1] * 0.7152 + RGB [2] * 0.0722\n",
    "   Z = RGB [0] * 0.0193 + RGB [1] * 0.1192 + RGB [2] * 0.9505\n",
    "   XYZ[ 0 ] = round( X, 4 )\n",
    "   XYZ[ 1 ] = round( Y, 4 )\n",
    "   XYZ[ 2 ] = round( Z, 4 )\n",
    "\n",
    "   XYZ[ 0 ] = float( XYZ[ 0 ] ) / 95.047         # ref_X =  95.047   Observer= 2°, Illuminant= D65\n",
    "   XYZ[ 1 ] = float( XYZ[ 1 ] ) / 100.0          # ref_Y = 100.000\n",
    "   XYZ[ 2 ] = float( XYZ[ 2 ] ) / 108.883        # ref_Z = 108.883\n",
    "\n",
    "   num = 0\n",
    "   for value in XYZ :\n",
    "\n",
    "       if value > 0.008856 :\n",
    "           value = value ** ( 0.3333333333333333 )\n",
    "       else :\n",
    "           value = ( 7.787 * value ) + ( 16 / 116 )\n",
    "\n",
    "       XYZ[num] = value\n",
    "       num = num + 1\n",
    "\n",
    "   Lab = [0, 0, 0]\n",
    "\n",
    "   L = ( 116 * XYZ[ 1 ] ) - 16\n",
    "   a = 500 * ( XYZ[ 0 ] - XYZ[ 1 ] )\n",
    "   b = 200 * ( XYZ[ 1 ] - XYZ[ 2 ] )\n",
    "\n",
    "   Lab [ 0 ] = round( L, 4 )\n",
    "   Lab [ 1 ] = round( a, 4 )\n",
    "   Lab [ 2 ] = round( b, 4 )\n",
    "\n",
    "   return Lab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################################################\n",
    "# Lab to sRGB\n",
    "# return : [R, G, B] / <class 'list'>\n",
    "##################################################################\n",
    "\n",
    "\n",
    "def lab2rgb ( inputColor ) :\n",
    "    rgb_ratio = convert_color(inputColor, sRGBColor)\n",
    "    rgb = [0, 0, 0]\n",
    "    rgb[0] = rgb_ratio.rgb_r * 255\n",
    "    rgb[1] = rgb_ratio.rgb_g * 255\n",
    "    rgb[1] = rgb_ratio.rgb_b * 255\n",
    "    return rgb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################################################\n",
    "# getPersonalColor\n",
    "# return : \"가을웜톤\" / <class 'String'>\n",
    "##################################################################\n",
    "\n",
    "def getPersonalColor(personal, season):\n",
    "    \n",
    "    result = \"\"\n",
    "    \n",
    "    if(personal[1] > personal[2]):\n",
    "        result += \"쿨톤\"\n",
    "        \n",
    "        if(season[0] > 50):\n",
    "            result = \"겨울\" + result\n",
    "        else:\n",
    "            result = \"여름\" + result\n",
    "            \n",
    "    else:\n",
    "        result += \"웜톤\"\n",
    "        \n",
    "        if(season[0] > 50):\n",
    "            result = \"봄\" + result\n",
    "        else:\n",
    "            result = \"가을\" + result\n",
    "            \n",
    "    return result"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}