Alphapose_DTW_RBF_v3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8b0b7e7d",
   "metadata": {},
   "source": [
    "# Alphapose 포즈 유사도(similarity) 측정 프로그램\n",
    "두 영상의 프레임별 포즈 유사도 (Similarity) 측정 프로그램\n",
    "\n",
    "처리 과정\n",
    "- 두 영상의 json 데이터를 가져옴\n",
    "- 두 영상의 json 데이터를 키포인트 배열로 변환 (36 차원 벡터)\n",
    "- 사용하는 키포인트 데이터만 추출하고 싶은 경우 해당 키포인트만 추출 가능\n",
    "- 두 영상의 키포인트 36차원 배열을 각각 유클리드 거리 1 로 조정\n",
    "- 30프레임당 아래의 알고리즘 반복\n",
    "    - 두 영상 프레임간의 키포인트 36차원 배열간 코사인 유사도 측정\n",
    "    - 위 코사인 유사도 값으로 다차원 벡터간의 유클리드 거리 계산\n",
    "    - 계산된 유클리드 거리를 직관적으로 판단하기 위해 가우시안 RBF 정규분포화 적용\n",
    "    - 30프레임의 평균 RBF 수치 90 미만인 경우 DTW 알고리즘 시작\n",
    "        - 이 소스의 DTW 알고리즘 : 각각 이전의 한프레임과 1차적으로 매칭, 매칭실패시 이후 사용자의 10프레임까지 탐색\n",
    "        - 만일 매칭된 두 시퀀스 사이에 0.3 DTW-Euclid 거리 이상의 매칭이 있었던 경우 해당 시퀀스도 평균 데이터에 적용\n",
    "        - 평균 DTW-RBF 가 90 이상인 경우 현재 두 프레임의 시작 위치를 결과 위치로 변동\n",
    "        - 평균 DTW-RBF 가 90 미만인 경우 DTW 데이터를 버리고 평균 RBF 수치가 90 미만인 원래 데이터를 전체 데이터에 적용( 다음 30 프레임 시작 위치도 DTW 미적용한 시작점 )\n",
    "    - 30프레임의 평균 RBF 수치 90 이상인 경우 DTW 를 생략하고 바로 다음 30프레임 포즈 유사도 RBF 연산 시작\n",
    "    - 마지막 프레임까지 반복\n",
    "- 연산된 전체 RBF 수치를 데이터 프레임으로 출력\n",
    "\n",
    "\n",
    "번외\n",
    "- 이동평균필터를 사용한 그래프 출력 기능(메인메소드 일부 수정 필요)\n",
    "\n",
    "코드 작성일 : 220621"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d54183d9",
   "metadata": {},
   "source": [
    "# Json 데이터 추출 파트\n",
    "ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ\n",
    "- 이미지 , 영상 , 캠(터미널에서만 돌리는 것을 권장) 의 json 데이터 추출 파트\n",
    "\n",
    "ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ\n",
    "- https://github.com/cisco/openh264/releases 에서 openh264 dll 맞는 OS bit 에 따라 다운 (링크 복사 새탭 )\n",
    "- C:\\Windows\\System32 에 dll 을 붙여넣기 ( 1.8.0 )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85bf4105",
   "metadata": {},
   "source": [
    "현재 디렉토리 위치 변경"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38044b0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.chdir('C:\\AR_project\\AlphaPose')\n",
    "print(os.getcwd())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfd9526a",
   "metadata": {},
   "source": [
    "# demo_inference.py 인자로 가능 한 것\n",
    "\n",
    "demo_inference.py [-h] --cfg CFG --checkpoint CHECKPOINT [--sp]\n",
    "                         [--detector DETECTOR] [--detfile DETFILE]\n",
    "                         [--indir INPUTPATH] [--list INPUTLIST]\n",
    "                         [--image INPUTIMG] [--outdir OUTPUTPATH] [--save_img]\n",
    "                         [--vis] [--showbox] [--profile] [--format FORMAT]\n",
    "                         [--min_box_area MIN_BOX_AREA] [--detbatch DETBATCH]\n",
    "                         [--posebatch POSEBATCH] [--eval] [--gpus GPUS]\n",
    "                         [--qsize QSIZE] [--flip] [--debug] [--video VIDEO]\n",
    "                         [--webcam WEBCAM] [--save_video] [--vis_fast]\n",
    "                         [--pose_flow] [--pose_track]\n",
    "                         \n",
    "                         \"\"\"----------------------------- Demo options -----------------------------\"\"\"\n",
    "- parser = argparse.ArgumentParser(description='AlphaPose Demo')\n",
    "- parser.add_argument('--cfg', type=str, required=True,\n",
    "                    help='experiment configure file name')                  \n",
    "- parser.add_argument('--checkpoint', type=str, required=True,\n",
    "                    help='checkpoint file name')                    \n",
    "- parser.add_argument('--sp', default=False, action='store_true',\n",
    "                    help='Use single process for pytorch')                    \n",
    "- parser.add_argument('--detector', dest='detector',\n",
    "                    help='detector name', default=\"yolo\")                    \n",
    "- parser.add_argument('--detfile', dest='detfile',\n",
    "                    help='detection result file', default=\"\")                    \n",
    "- parser.add_argument('--indir', dest='inputpath',\n",
    "                    help='image-directory', default=\"\")                   \n",
    "- parser.add_argument('--list', dest='inputlist',\n",
    "                    help='image-list', default=\"\")                  \n",
    "- parser.add_argument('--image', dest='inputimg',\n",
    "                    help='image-name', default=\"\")                    \n",
    "- parser.add_argument('--outdir', dest='outputpath',\n",
    "                    help='output-directory', default=\"examples/res/\")                    \n",
    "- parser.add_argument('--save_img', default=False, action='store_true',\n",
    "                    help='save result as image')                    \n",
    "- parser.add_argument('--vis', default=False, action='store_true',\n",
    "                    help='visualize image')                    \n",
    "- parser.add_argument('--showbox', default=False, action='store_true',\n",
    "                    help='visualize human bbox')                    \n",
    "- parser.add_argument('--profile', default=False, action='store_true',\n",
    "                    help='add speed profiling at screen output')                    \n",
    "- parser.add_argument('--format', type=str,\n",
    "                    help='save in the format of cmu or coco or openpose, option: coco/cmu/open')                    \n",
    "- parser.add_argument('--min_box_area', type=int, default=0,\n",
    "                    help='min box area to filter out')                    \n",
    "- parser.add_argument('--detbatch', type=int, default=5,\n",
    "                    help='detection batch size PER GPU')                    \n",
    "- parser.add_argument('--posebatch', type=int, default=64,\n",
    "                    help='pose estimation maximum batch size PER GPU')\n",
    "- parser.add_argument('--eval', dest='eval', default=False, action='store_true',\n",
    "                    help='save the result json as coco format, using image index(int) instead of image name(str)')                    \n",
    "- parser.add_argument('--gpus', type=str, dest='gpus', default=\"0\",\n",
    "                    help='choose which cuda device to use by index and input comma to use multi gpus, e.g. 0,1,2,3. (input -1 for cpu only)')\n",
    "- parser.add_argument('--qsize', type=int, dest='qsize', default=1024,\n",
    "                    help='the length of result buffer, where reducing it will lower requirement of cpu memory')                    \n",
    "- parser.add_argument('--flip', default=False, action='store_true',\n",
    "                    help='enable flip testing')                    \n",
    "- parser.add_argument('--debug', default=False, action='store_true',\n",
    "                    help='print detail information')                    \n",
    "\"\"\"----------------------------- Video options -----------------------------\"\"\"\n",
    "- parser.add_argument('--video', dest='video',\n",
    "                    help='video-name', default=\"\")                    \n",
    "- parser.add_argument('--webcam', dest='webcam', type=int,\n",
    "                    help='webcam number', default=-1)                    \n",
    "- parser.add_argument('--save_video', dest='save_video',\n",
    "                    help='whether to save rendered video', default=False, action='store_true')                    \n",
    "- parser.add_argument('--vis_fast', dest='vis_fast',\n",
    "                    help='use fast rendering', action='store_true', default=False)                    \n",
    "\"\"\"----------------------------- Tracking options -----------------------------\"\"\"\n",
    "- parser.add_argument('--pose_flow', dest='pose_flow',\n",
    "                    help='track humans in video with PoseFlow', action='store_true', default=False)                    \n",
    "- parser.add_argument('--pose_track', dest='pose_track',\n",
    "                    help='track humans in video with reid', action='store_true', default=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd5985b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "#이미지용\n",
    "#이미지 위치 : examples / demo / images\n",
    "#결과 저장 json 위치 : examples / res\n",
    "#결과 저장 이미지 위치 : examplse / res / vis\n",
    "! python scripts/demo_inference.py --cfg configs/coco/resnet/256x192_res50_lr1e-3_1x.yaml --checkpoint pretrained_models/fast_res50_256x192.pth --indir examples/demo/images --save_img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "862b012c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#캠용\n",
    "#터미널에서만 Ctrl+C 로 종료가능\n",
    "! python scripts/demo_inference.py --cfg configs/coco/resnet/256x192_res50_lr1e-3_1x.yaml --checkpoint pretrained_models/fast_res50_256x192.pth --outdir examples/res --vis --webcam 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "443fbda1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#비디오용\n",
    "#비디오 위치 : examples / demo / dance_video / guide_1.mp4\n",
    "#결과 저장 json 위치 : examples / res\n",
    "#결과 저장 비디오 위치 : examplse / res\n",
    "# 영상이 5MB 를 넘으면 프리징 됨 인코딩 처리해서 5MB 미만으로 https://www.videosmaller.com/ko/\n",
    "! python scripts/demo_inference.py --cfg configs/coco/resnet/256x192_res50_lr1e-3_1x.yaml --checkpoint pretrained_models/fast_res50_256x192.pth --video examples/demo/dance_video/guide_4.mp4 --outdir examples/res --save_video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53a51327",
   "metadata": {},
   "outputs": [],
   "source": [
    "#결과 json 열기\n",
    "import json\n",
    "with open('examples/res/alphapose-guide_1_results.json') as f:\n",
    "  data = json.load(f)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22640ba2",
   "metadata": {},
   "outputs": [],
   "source": [
    "#json 데이터 결과를 데이터 프레임 표로 시각화\n",
    "import pandas as pd\n",
    "df = pd.read_json('examples/res/alphapose-results.json')\n",
    "#df = pd.read_json('examples/res/alphapose-dancer_results.json')\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaaaa4aa",
   "metadata": {},
   "source": [
    "# 추출 파트 END\n",
    "ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ\n",
    "- 이후는 두 영상의 데이터를 확인하는 소스\n",
    "\n",
    "ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "036ce928",
   "metadata": {},
   "source": [
    "# 데이터 확인\n",
    "데이터 확인 메소드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96802c61",
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_table(guide_json_path,user_json_path):\n",
    "    \n",
    "    import os\n",
    "    os.chdir('C:\\AR_project\\AlphaPose')\n",
    "    \n",
    "    import pandas as pd\n",
    "\n",
    "    guide_df = pd.read_json(guide_json_path)\n",
    "    user_df = pd.read_json(user_json_path)\n",
    "    return guide_df,user_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c542490",
   "metadata": {},
   "outputs": [],
   "source": [
    "guide_df,user_df = show_table('examples/res/alphapose-right_2_results.json','examples/res/alphapose-wrong_2_results.json');\n",
    "guide_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c82baf11",
   "metadata": {},
   "outputs": [],
   "source": [
    "user_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a30201d4",
   "metadata": {},
   "source": [
    "# 확인 파트 END\n",
    "ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ\n",
    "- 이후는 두 영상의 키포인트 데이터의 프레임별 포즈 유사도를 구하는 소스\n",
    "- !! 현재는 영상에 사람이 한명인 경우만 포즈 유사도를 측정할 수 있습니다\n",
    "\n",
    "ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "917dc62d",
   "metadata": {},
   "source": [
    "# 디렉토리 위치 변경\n",
    "현재 쥬피터 os 디렉토리 변경 메소드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3aa8690d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.chdir('C:\\AR_project\\AlphaPose')\n",
    "print(os.getcwd())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dee021cf",
   "metadata": {},
   "source": [
    "# 키포인트 배열 데이터로 처리\n",
    "json 데이터를 키포인트 / 컨피던스 스코어 배열 데이터로 처리하는 메소드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6138686",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_keypoints_list(json_path):\n",
    "    \n",
    "    import json\n",
    "    \n",
    "    with open(json_path) as g:\n",
    "        json_data = json.load(g)\n",
    "        \n",
    "    keypoints_list=[]\n",
    "    \n",
    "    for keypoints in json_data:\n",
    "        klen = len(keypoints['keypoints'])\n",
    "        i = 2\n",
    "        while i <= klen - 1 :\n",
    "            keypoints['keypoints'].pop(i)\n",
    "            i = i + 2\n",
    "            klen = klen - 1\n",
    "        keypoints_list.append(keypoints['keypoints'])\n",
    "    \n",
    "    return keypoints_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf80deae",
   "metadata": {},
   "source": [
    "# 사용하는 벡터만 반환\n",
    "키포인트 벡터 데이터중 사용하는 벡터만 반환하는 메소드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c08611c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_use_keypoint(keypoints_data,usekeyp):\n",
    "    \n",
    "    need_keypoints_data = []\n",
    "    for keypoints in keypoints_data:\n",
    "        need_keypoints = []\n",
    "        for use in usekeyp:\n",
    "            need_keypoints.append(keypoints[2*use])\n",
    "            need_keypoints.append(keypoints[2*use+1])\n",
    "        need_keypoints_data.append(need_keypoints)\n",
    "        \n",
    "    return need_keypoints_data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ec64301",
   "metadata": {},
   "source": [
    "# 유클리드 거리 1 벡터 처리 객체 반환\n",
    "데이터들의 유클리드 거리를 1으로 조정하는 가이드 영상 기준의 트랜스 포머 객체 반환 메소드\n",
    "- kearn 모듈 없으면 설치해야함 \n",
    "https://blog.naver.com/PostView.naver?blogId=jaeyoon_95&logNo=222007026711&parentCategoryNo=&categoryNo=120&viewDate=&isShowPopularPosts=true&from=search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19518865",
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_euclid_one_tf(guide_vector_data):\n",
    "    \n",
    "    from sklearn.preprocessing import Normalizer\n",
    "    \n",
    "    transformer = Normalizer().fit(guide_vector_data)\n",
    "\n",
    "    return transformer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d674a10",
   "metadata": {},
   "source": [
    "# 코사인 시밀러리티\n",
    "코사인 시밀러리티 메소드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c2e67e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def CosineSimilarity(first_vector, second_vector):\n",
    "    import numpy as np\n",
    "    a = np.matmul(np.transpose(first_vector), second_vector)\n",
    "    b = np.sum(np.multiply(first_vector, first_vector))\n",
    "    c = np.sum(np.multiply(second_vector, second_vector))\n",
    "    return a / (np.sqrt(b) * np.sqrt(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11a545f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def max_min_error_confirm(cossim,max=1,min=-1):\n",
    "    if cossim > max :\n",
    "        cossim = max\n",
    "    elif cossim < min :\n",
    "        cossim = min\n",
    "    return cossim"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e516f4d",
   "metadata": {},
   "source": [
    "# 벡터간의 유클리디안 거리(Use Css)\n",
    "벡터간의 유클리디안 거리 메소드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8a6ebd8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_css_euclid(Css):\n",
    "    import numpy as np\n",
    "    return np.sqrt(2*(1-Css))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98454868",
   "metadata": {},
   "source": [
    "# 가우시안 RBF 처리(Use euclid D)\n",
    "유클리드 거리의 가우시안 RBF 처리\n",
    "- 방사형 기저 함수 양의 정부호 함수 '바레실론'은 2를 사용하였음"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "186ab8ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_euclid_RBF(euclidD):\n",
    "    import numpy as np\n",
    "    rbfr = np.exp(-1*((2*euclidD)**2))\n",
    "    #rbfr = np.exp(-1*((euclidD**2)/2*(0.2**2)))\n",
    "    return rbfr;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4ca7601",
   "metadata": {},
   "source": [
    "# 벡터간의 DTW 용 최단 거리\n",
    "DTW 가 적용된 다차원 벡터간의 유클리드 거리 메소드\n",
    "- 벡터간의 최단 유클리드 거리를 구한다\n",
    "\n",
    "pip install dtaidistance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3959de92",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dtw_distanse(first_vector, second_vector):\n",
    "    from dtaidistance import dtw\n",
    "    from dtaidistance import dtw_visualisation as dtwvis\n",
    "    \n",
    "    distance = dtw.distance(first_vector, second_vector)\n",
    "\n",
    "    \n",
    "    return distance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79b21535",
   "metadata": {},
   "source": [
    "# 두 구간별 프레임에 대하여 DTW 후 RBF 평균수치가 일정값 이상인 경우를 판별\n",
    "두 구간별 프레임에 대하여 DTW 후 RBF 평균수치가 일정값 이상인 경우를 검증, 결과 반환 메소드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "384ba28c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dtw_match(guide_kpl,guide_start_frame,user_kpl,user_start_frame,find_frame_limit,eus_limit,eus_overlimit,sucess_grade) :\n",
    "    \n",
    "    import numpy as np\n",
    "    \n",
    "    result_user_end_frame = 0;\n",
    "    \n",
    "    ukpl_last = len(user_kpl)\n",
    "    gets = []\n",
    "    j = -1\n",
    "    i = -1\n",
    "    guide_frame = []\n",
    "    user_frame = []\n",
    "    \n",
    "    \n",
    "    while i < len(guide_kpl) - 1:\n",
    "        j = j + 1\n",
    "        i = i + 1\n",
    "\n",
    "        if j == ukpl_last :\n",
    "            #j = ukpl_last - 1\n",
    "            break\n",
    "        \n",
    "        temp_gets = []\n",
    "        temp_gets.append(dtw_distanse(guide_kpl[i],user_kpl[j]))\n",
    "        \n",
    "        if j != 0 and i != 0 :\n",
    "            temp_gets.append(dtw_distanse(guide_kpl[i],user_kpl[j-1]))\n",
    "            temp_gets.append(dtw_distanse(guide_kpl[i-1],user_kpl[j]))\n",
    "        else :\n",
    "            temp_gets.append(1)\n",
    "            temp_gets.append(1)\n",
    "        \n",
    "        min_temp_gets = 0\n",
    "        min_temp_gets = min(temp_gets)\n",
    "        \n",
    "        temp_gets_index = 0\n",
    "        temp_gets_index = temp_gets.index(min_temp_gets)\n",
    "        \n",
    "        if min_temp_gets < eus_limit :\n",
    "            \n",
    "            if temp_gets[0] < eus_limit :\n",
    "                gets.append(temp_gets[0])\n",
    "                guide_frame.append(i)\n",
    "                user_frame.append(j)\n",
    "            \n",
    "            elif temp_gets[0] > eus_limit and temp_gets_index == 1 :\n",
    "                gets.append(temp_gets[1])\n",
    "                guide_frame.append(i)\n",
    "                user_frame.append(j-1)\n",
    "                j = j - 1\n",
    "            elif temp_gets[0] > eus_limit and temp_gets_index == 2 :\n",
    "                gets.append(temp_gets[2])\n",
    "                guide_frame.append(i-1)\n",
    "                user_frame.append(j)\n",
    "                i = i - 1\n",
    "        \n",
    "        elif min_temp_gets > eus_limit :\n",
    "            temp_gets_in = []\n",
    "            #더미데이터\n",
    "            temp_gets_in.append(1)\n",
    "            \n",
    "            for_j = j\n",
    "            using_index = 0;\n",
    "            while temp_gets_in[using_index] > eus_limit and (for_j + 1) <= (j + find_frame_limit) :\n",
    "                \n",
    "                using_index = using_index + 1\n",
    "                \n",
    "                for_j = for_j + 1\n",
    "                \n",
    "                if for_j >= ukpl_last :\n",
    "                    if temp_gets_index == 0 :\n",
    "                        gets.append(temp_gets[0])\n",
    "                        guide_frame.append(i)\n",
    "                        user_frame.append(j)\n",
    "                    elif temp_gets_index == 1 :\n",
    "                        gets.append(temp_gets[1])\n",
    "                        guide_frame.append(i)\n",
    "                        user_frame.append(j-1)\n",
    "                    elif temp_gets_index == 2 :\n",
    "                        gets.append(temp_gets[2])\n",
    "                        guide_frame.append(i-1)\n",
    "                        user_frame.append(j) \n",
    "\n",
    "                    break;\n",
    "                \n",
    "                temp_gets_in.append(dtw_distanse(guide_kpl[i],user_kpl[for_j]))\n",
    "                \n",
    "                if temp_gets_in[using_index] > eus_overlimit :\n",
    "                    \n",
    "                    gets.append(temp_gets_in[using_index])\n",
    "                    guide_frame.append(i)\n",
    "                    user_frame.append(for_j)\n",
    "\n",
    "                    break\n",
    "                \n",
    "                \n",
    "                if temp_gets_in[using_index] < eus_limit :\n",
    "\n",
    "                    j = for_j\n",
    "                    gets.append(temp_gets_in[using_index])\n",
    "                    guide_frame.append(i)\n",
    "                    user_frame.append(j)\n",
    "                    \n",
    "                    break\n",
    "\n",
    "                if temp_gets_in[using_index] > eus_limit and for_j == (j + find_frame_limit) :\n",
    "\n",
    "                    gets.append(temp_gets[0])\n",
    "                    guide_frame.append(i)\n",
    "                    user_frame.append(j)\n",
    "\n",
    "                    break;\n",
    "        \n",
    "    dtw_part_euclid = []\n",
    "    dtw_part_RBF = []\n",
    "\n",
    "    for i in range(len(guide_frame)):\n",
    "        temp_euclid = 0;\n",
    "        temp_euclid = max_min_error_confirm(CosineSimilarity(guide_kpl[guide_frame[i]],user_kpl[user_frame[i]]))\n",
    "        dtw_part_euclid.append(get_css_euclid(temp_euclid))\n",
    "        temp_euclid = get_css_euclid(temp_euclid)\n",
    "        dtw_part_RBF.append(get_euclid_RBF(temp_euclid))\n",
    "    \n",
    "    if np.mean(dtw_part_RBF) < sucess_grade :\n",
    "\n",
    "        return [],[],0,[],0,[]\n",
    "\n",
    "    else :\n",
    "        \n",
    "        for i in range(len(user_frame)) :\n",
    "            user_frame[i] = user_frame[i] + user_start_frame\n",
    "\n",
    "        for i in range(len(guide_frame)) :\n",
    "            guide_frame[i] = guide_frame[i] + guide_start_frame\n",
    "\n",
    "        return dtw_part_euclid,dtw_part_RBF,np.max(user_frame),user_frame,np.max(guide_frame),guide_frame\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25be92cf",
   "metadata": {},
   "source": [
    "# 이동 평균 필터\n",
    "데이터의 이동평균 반환 ( 그래프 뽑을 때 사용 )\n",
    "\n",
    "파이썬의 오류 조심\n",
    "파이썬은 메소드를 호출할때 해당 변수로 구조형을 넘겨주고 그 메소드안에서 해당 구조형의 값이 바뀌면\n",
    "값이 바뀐 그 구조형을 리턴하지 않아도 해당 메소드가 끝난 후 넘겨준 구조형의 값은 변경되어 있다\n",
    "\n",
    "-a = [1,2,3,4,5]\n",
    "\n",
    "-def aaa(a) :\n",
    "-    a.append(6)\n",
    "-    return 0;\n",
    "\n",
    "-b = aaa(a)\n",
    "\n",
    "-a\n",
    "\n",
    "-out : [1,2,3,4,5,6]\n",
    "\n",
    "-append 는 구조를 바꾸는 것이기 때문에 조심해야됨\n",
    "-a.append(6) 가 아니라 a = [1,2,3,4,5,6] 인 경우(자료형변경)에는\n",
    "-out 이 [1,2,3,4,5] 로 나온다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f93a1e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def MovingAverageFilter(x_n, x_meas):\n",
    "    \n",
    "    # x_n : 이전까지의 데이터들\n",
    "    # x_meas : 현재의 데이터\n",
    "    # x_avg (return) : 이동평균값\n",
    "    \n",
    "    import numpy as np\n",
    "    import matplotlib.pyplot as plt\n",
    "    from scipy import io\n",
    "    \n",
    "    temp_x_n = []\n",
    "    temp_x_n = list(x_n)\n",
    "    \n",
    "    n = len(temp_x_n)\n",
    "    \n",
    "    if(n == 0):\n",
    "        x_avg = x_meas;\n",
    "    else :  \n",
    "        for i in range(n-1):\n",
    "            temp_x_n[i] = temp_x_n[i+1]\n",
    "        temp_x_n[n-1] = x_meas\n",
    "        x_avg = np.mean(temp_x_n)\n",
    "\n",
    "    return x_avg"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c14b7b16",
   "metadata": {},
   "source": [
    "# 유사도 측정 메인 메소드\n",
    "두 영상의 각 프레임 별 유사도 배열을 반환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6db93ac5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_cossim_in_json(guide_json_path,user_json_path,usekeyp=[],method=\"cos\"):\n",
    "    guide_kpl = get_keypoints_list(guide_json_path)\n",
    "    user_kpl = get_keypoints_list(user_json_path)\n",
    "    \n",
    "    guide_cons = []\n",
    "    user_cons = []\n",
    "    \n",
    "    if len(usekeyp) != 0:\n",
    "        guide_kpl = get_use_keypoint(guide_kpl,usekeyp)\n",
    "        user_kpl = get_use_keypoint(user_kpl,usekeyp)\n",
    "    \n",
    "    \"\"\"\n",
    "    import matplotlib.pyplot as plt\n",
    "    for kpl in guide_kpl:\n",
    "        i = 0\n",
    "        while i < len(kpl):\n",
    "            plt.scatter(kpl[i],kpl[i+1])\n",
    "            plt.text(kpl[i], kpl[i+1], i/2, fontsize=12)\n",
    "            i = i+2\n",
    "        plt.show()\n",
    "    \"\"\"\n",
    "    \"\"\"\n",
    "    for i in range(len(guide_kpl)):\n",
    "        transformer = change_euclid_one_tf([guide_kpl[i]])\n",
    "        guide_kpl[i] = transformer.transform([guide_kpl[i]])\n",
    "    \"\"\"\n",
    "    \n",
    "\n",
    "    transformer = change_euclid_one_tf(guide_kpl)\n",
    "    guide_kpl=transformer.transform(guide_kpl)\n",
    "    user_kpl=transformer.transform(user_kpl)\n",
    "    \n",
    "    if method==\"dtw\":\n",
    "        #허용하는 프레임 차이 ( 15 = 0.5초 )\n",
    "        find_frame_limit = 10;\n",
    "        #허용하는 dtw euclid 거리\n",
    "        eus_limit = 0.15;\n",
    "        #dtw 매치된 두 프레임 사이에서 측정값이 일정값만큼 오버될 경우 데이터로 기록 하는 수치\n",
    "        eus_overlimit = 0.30;\n",
    "        #비교하는 프레임 단위\n",
    "        match_frame_limit = 30;\n",
    "        #허용하는 프레임별 rbf 점수\n",
    "        sucess_grade = 0.90;\n",
    "        \n",
    "        guide_end_frame = 0;\n",
    "        guide_start_frame = 0;\n",
    "        user_end_frame = 0;\n",
    "        user_start_frame = 0;\n",
    "        \n",
    "        guide_frame = []\n",
    "        user_frame = []\n",
    "        \n",
    "        roof_bool = True;\n",
    "        \n",
    "        euclid = []\n",
    "        RBF = []\n",
    "        \n",
    "        import numpy as np\n",
    "        \n",
    "        while roof_bool :\n",
    "            \n",
    "            part_euclid = []\n",
    "            part_RBF = []\n",
    "        \n",
    "            guide_start_frame = guide_end_frame\n",
    "            user_start_frame = user_end_frame\n",
    "        \n",
    "            for i in range(match_frame_limit) :\n",
    "                \n",
    "                if(guide_end_frame + i < len(guide_kpl)) and (user_end_frame + i < len(user_kpl)) :\n",
    "                    #print(guide_end_frame + i)\n",
    "                    part_temp_euclid = 0;\n",
    "                    part_temp_euclid = max_min_error_confirm(CosineSimilarity(guide_kpl[guide_end_frame + i],user_kpl[user_end_frame + i]))\n",
    "                    part_euclid.append(get_css_euclid(part_temp_euclid))\n",
    "                    part_temp_euclid = get_css_euclid(part_temp_euclid)\n",
    "                    part_RBF.append(get_euclid_RBF(part_temp_euclid))\n",
    "                    \n",
    "                    if(i == match_frame_limit-1) :\n",
    "                        guide_end_frame = guide_end_frame + i + 1\n",
    "                        user_end_frame = user_end_frame + i + 1\n",
    "                    \n",
    "                else :\n",
    "                    guide_end_frame = guide_end_frame + i\n",
    "                    user_end_frame = user_end_frame + i\n",
    "                    roof_bool = False;\n",
    "                    break;\n",
    "            \n",
    "            if np.mean(part_RBF) < sucess_grade :\n",
    "                \n",
    "                match_euclid = []\n",
    "                match_RBF = []\n",
    "                result_user_end_frame = 0\n",
    "                user_part_frame = []\n",
    "                guide_part_frame = []\n",
    "                match_euclid,match_RBF,result_user_end_frame,user_part_frame,result_guide_end_frame,guide_part_frame = dtw_match(guide_kpl[guide_start_frame:guide_end_frame],guide_start_frame,user_kpl[user_start_frame:],user_start_frame,find_frame_limit,eus_limit,eus_overlimit,sucess_grade)\n",
    "                \n",
    "                if (result_user_end_frame == 0):\n",
    "                    euclid = euclid + part_euclid\n",
    "                    RBF = RBF + part_RBF\n",
    "\n",
    "                    \n",
    "                else :\n",
    "\n",
    "                    user_end_frame = result_user_end_frame + 1\n",
    "                    guide_end_frame = result_guide_end_frame + 1\n",
    "                    euclid = euclid + match_euclid\n",
    "                    RBF = RBF + match_RBF\n",
    "                    \n",
    "                    guide_frame = guide_frame + guide_part_frame\n",
    "                    user_frame = user_frame + user_part_frame\n",
    "\n",
    "                    continue;\n",
    "                \n",
    "            else :\n",
    "                euclid = euclid + part_euclid\n",
    "                RBF = RBF + part_RBF\n",
    "            \n",
    "            guide_part_frame = []\n",
    "            for i in range(guide_end_frame - guide_start_frame):\n",
    "                guide_part_frame.append(str(guide_start_frame + i))\n",
    "            guide_frame = guide_frame + guide_part_frame\n",
    "            user_part_frame = []\n",
    "            for i in range(user_end_frame - user_start_frame):\n",
    "                user_part_frame.append(str(user_start_frame + i))\n",
    "            user_frame = user_frame + user_part_frame\n",
    "        \n",
    "        \n",
    "        frame_distance = []\n",
    "        for i in range(len(user_frame)) :\n",
    "            \n",
    "            if i == 0 :\n",
    "                frame_distance.append(int(user_frame[i]) - (-1))\n",
    "                continue\n",
    "            frame_distance.append(int(user_frame[i]) - int(user_frame[i-1]))\n",
    "        \n",
    "        result = []\n",
    "        #result.append(gets)\n",
    "        result.append(guide_frame)\n",
    "        result.append(user_frame)\n",
    "        result.append(frame_distance)\n",
    "        result.append(euclid)\n",
    "        result.append(RBF)\n",
    "        \n",
    "        #result.append([np.mean(gets)])\n",
    "        result.append([np.mean(euclid)])\n",
    "        result.append([np.mean(RBF)])\n",
    "        \n",
    "        forran = len(guide_frame)\n",
    "        \n",
    "        import pandas as pd\n",
    "        column_names=[]\n",
    "        for i in range(forran):\n",
    "            column_names.append(str(i))\n",
    "        #data=pd.DataFrame(result,columns=column_names,index=['DTW_Euclid','G_frame','U_frame','frame_D','Euclid','RBF','DTW_Euclid-AVER','Eulid-AVER','RBF-AVER'])\n",
    "        data=pd.DataFrame(result,columns=column_names,index=['G_frame','U_frame','frame_D','Euclid','RBF','Eulid-AVER','RBF-AVER'])\n",
    "        data.transpose()\n",
    "        data.fillna('',inplace=True)\n",
    "    \n",
    "    else :\n",
    "        guide_kpl_length = len(guide_kpl)\n",
    "        user_kpl_length = len(user_kpl)\n",
    "        forran = min((guide_kpl_length,user_kpl_length))\n",
    "        result = []\n",
    "        MAF = []\n",
    "        for i in range(forran):\n",
    "            if method==\"cos\":\n",
    "                #MAF.append(MovingAverageFilter(result,max_min_error_confirm(CosineSimilarity(guide_kpl[i],user_kpl[i]))))\n",
    "                result.append(max_min_error_confirm(CosineSimilarity(guide_kpl[i],user_kpl[i])))\n",
    "            elif method==\"euc\":\n",
    "                temp_result = 0;\n",
    "                temp_result = max_min_error_confirm(CosineSimilarity(guide_kpl[i],user_kpl[i]))\n",
    "                result.append(get_css_euclid(temp_result))\n",
    "            elif method==\"rbf\":\n",
    "                temp_result = 0;\n",
    "                temp_result = max_min_error_confirm(CosineSimilarity(guide_kpl[i],user_kpl[i]))\n",
    "                temp_result = get_css_euclid(temp_result)\n",
    "                #MAF.append(MovingAverageFilter(result,get_euclid_RBF(temp_result)))\n",
    "                result.append(get_euclid_RBF(temp_result))\n",
    "        \"\"\"\n",
    "        import numpy as np\n",
    "        x = np.arange(0, 364)\n",
    "        y = result[:364]\n",
    "        yy = MAF[:364]\n",
    "        \"\"\"   \n",
    "        \n",
    "        import numpy as np\n",
    "        aver = []\n",
    "        aver.append(np.mean(result))\n",
    "        result = [result]\n",
    "        result.append(aver)\n",
    "        index = \"\"\n",
    "        if method==\"cos\":\n",
    "            index = \"Cos_sim\"\n",
    "        if method==\"euc\":\n",
    "            index = \"Euclid\"\n",
    "        if method==\"rbf\":\n",
    "            index = \"RBF\"\n",
    "        import pandas as pd\n",
    "        column_names=[]\n",
    "        for i in range(forran):\n",
    "            column_names.append(str(i))\n",
    "        data=pd.DataFrame(result,columns=column_names,index=[index,index + '-AVER'])\n",
    "        data.transpose()\n",
    "        data.fillna('',inplace=True)\n",
    "\n",
    "    pd.set_option('display.max_rows', None)\n",
    "     \n",
    "    return data.T #x,y,yy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45c7e217",
   "metadata": {},
   "source": [
    "-    {0,  \"Nose\"},\n",
    "-    {1,  \"LEye\"},\n",
    "-    {2,  \"REye\"},\n",
    "-    {3,  \"LEar\"},\n",
    "-    {4,  \"REar\"},\n",
    "-    {5,  \"LShoulder\"},\n",
    "-    {6,  \"RShoulder\"},\n",
    "-    {7,  \"LElbow\"},\n",
    "-    {8,  \"RElbow\"},\n",
    "-    {9,  \"LWrist\"},\n",
    "-    {10, \"RWrist\"},\n",
    "-    {11, \"LHip\"},\n",
    "-    {12, \"RHip\"},\n",
    "-    {13, \"LKnee\"},\n",
    "-    {14, \"Rknee\"},\n",
    "-    {15, \"LAnkle\"},\n",
    "-    {16, \"RAnkle\"},\n",
    "--------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "585b9a0c",
   "metadata": {},
   "source": [
    "# 데이터 프레임 용 예시 코드\n",
    "데이터 프레임 출력용 예시 코드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa8ea99c",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = get_cossim_in_json('examples/res/alphapose-guide_4_results.json','examples/res/alphapose-right_4_results.json',usekeyp=[7,8,9,10],method=\"dtw\");\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15541d4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = get_cossim_in_json('examples/res/alphapose-guide_4_results.json','examples/res/alphapose-wrong_4_results.json',usekeyp=[7,8,9,10],method=\"dtw\");\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdd0dc9b",
   "metadata": {},
   "source": [
    "# 그래프 용 예시 코드\n",
    "그래프 출력용 예시 코드\n",
    "- 메인메소드를 수정해주고 사용해야함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff4a3c9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#그래프 용 참고\n",
    "x , y1 , yy1 = get_cossim_in_json('examples/res/alphapose-dancer_results.json','examples/res/alphapose-right_dance_results.json',usekeyp=[],method=\"rbf\");\n",
    "\n",
    "x1, y2 , yy2 = get_cossim_in_json('examples/res/alphapose-dancer_results.json','examples/res/alphapose-wrong_dance_results.json',usekeyp=[],method=\"rbf\");\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(x, y1, color='lightgreen')\n",
    "\n",
    "plt.plot(x, y2, color='moccasin')\n",
    "\n",
    "plt.plot(x, yy1, label='same action', color='green')\n",
    "plt.plot(x, yy2, label='different action', color='orange')\n",
    "\n",
    "plt.xlabel('frames')\n",
    "plt.ylabel('RBF similarity')\n",
    "plt.ylim([0, 1])\n",
    "plt.legend()\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f7d2021",
   "metadata": {},
   "outputs": [],
   "source": [
    "#그래프 용 참고\n",
    "x , y1 , yy1 = get_cossim_in_json('examples/res/alphapose-dancer_results.json','examples/res/alphapose-right_dance_results.json',usekeyp=[],method=\"cos\");\n",
    "\n",
    "x1, y2 , yy2 = get_cossim_in_json('examples/res/alphapose-dancer_results.json','examples/res/alphapose-wrong_dance_results.json',usekeyp=[],method=\"cos\");\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(x, y1, color='lightgreen')\n",
    "\n",
    "plt.plot(x, y2, color='moccasin')\n",
    "\n",
    "plt.plot(x, yy1, label='same action', color='green')\n",
    "plt.plot(x, yy2, label='different action', color='orange')\n",
    "\n",
    "plt.xlabel('frames')\n",
    "plt.ylabel('COS similarity')\n",
    "\n",
    "plt.ylim([0, 1])\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c203dc53",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}