import hashlib
import pprint
import tqdm
import cv2
import re
import json
import io
import xarray
import numpy
import glob
import os
import pandas
import pickle
import subprocess


def kernel_1():
	t4 = 'kernel_1-t3.dat'

	def preprocess(t4):
		t1 = '/kaggle/input/mlb-player-digital-engagement-forecasting'
		t2 = glob.glob(os.path.join(t1, '*.csv'))

		t3 = {o: pandas.read_csv(o).to_xarray() for o in t2}

		with io.open(t4, 'wb') as f:
			pickle.dump(t3, f)

	if not os.path.exists(t4):
		preprocess(t4=t4)

	with io.open(t4, 'rb') as f:
		t3 = pickle.load(f)

	return dict(
		t3=t3,
	)


def kernel_2(
	o_1=None,
):
	t1 = {}

	for k in ['playerTwitterFollowers', 'teamTwitterFollowers', 'games', 'events']:
		t4 = '%s.nc' % k
		if not os.path.exists(t4):
			print('started %s' % t4)
			t2 = '/kaggle/input/mlb-player-digital-engagement-forecasting/train.csv'
			t3 = pandas.DataFrame(sum([json.loads(o) for o in o_1['t3'][t2][k].values if isinstance(o, str)], [])).to_xarray()
			t3.to_netcdf(t4)
			print('cached %s' % t4)

		if k == 'events':
			t5 = '%s-v2.nc' % k
			if not os.path.exists(t5):
				t2 = xarray.load_dataset(t4)
				t3 = t2.sel(index=numpy.arange(2017653 - 10 * 1000, 2017653 + 1))
				t3.to_netcdf(t5)
			t1[k] = xarray.load_dataset(t5)
			print('loaded %s' % t5)
		else:
			t1[k] = xarray.load_dataset(t4)
			print('loaded %s' % t4)

	return dict(
		t1=t1,
	)


def kernel_3(should_exist=None):
	if should_exist is None:
		should_exist = False

	t3 = [
		('playerTwitterFollowers', None),
		('teamTwitterFollowers', None),
		('games', None),
		('events', 'events-v2.nc'),
	]

	o_1 = None
	o_2 = None

	t4 = '/kaggle/input/garbage'
	t5 = {}
	for k, v in t3:
		if v is None:
			t1 = os.path.join(
				t4,
				'%s.nc' % k,
			)
		else:
			t1 = os.path.join(
				t4,
				v,
			)

		if os.path.exists(t1):
			t2 = xarray.load_dataset(t1)
		else:
			if should_exist:
				pprint.pprint([k, v, t1])
				raise NotImplementedError

			if o_1 is None:
				o_1 = kernel_1()
			if o_2 is None:
				o_2 = kernel_2(o_1=o_1)

			t2 = o_2['events']
		t5[k] = t2

	return dict(
		t5=t5,
	)


def kernel_4(
	o_3=None,
):
	[print(o_3['t5']['events'].to_dataframe().iloc[k].to_json(indent=4)) for k in range(-10, -1)]

	[print(o_3['t5']['games'].to_dataframe().iloc[k].to_json(indent=4)) for k in range(-10, -1)]

	t4 = 'https://www.youtube.com/watch?v=reaC7BHgL3M'

	r"""
        {
            "gamePk":634280,
            "gameType":"R",
            "season":2021,
            "gameDate":"2021-04-30",
            "gameTimeUTC":"2021-04-30T23:37:00Z",
            "resumeDate":"",
            "resumedFrom":"",
            "codedGameState":"F",
            "detailedGameState":"Final",
            "isTie":0.0,
            "gameNumber":1,
            "doubleHeader":"N",
            "dayNight":"night",
            "scheduledInnings":9,
            "gamesInSeries":3.0,
            "seriesDescription":"Regular Season",
            "homeId":141,
            "homeName":"Toronto Blue Jays",
            "homeAbbrev":"TOR",
            "homeWins":12,
            "homeLosses":12,
            "homeWinPct":0.5,
            "homeWinner":true,
            "homeScore":13.0,
            "awayId":144,
            "awayName":"Atlanta Braves",
            "awayAbbrev":"ATL",
            "awayWins":12.0,
            "awayLosses":14.0,
            "awayWinPct":0.462,
            "awayWinner":false,
            "awayScore":5.0
        }
    """

	t1 = numpy.where(o_3['t5']['events']['gamePk'] == 634280)[0]
	t5 = o_3['t5']['events'].index.data
	t6 = t5[t1]
	t2 = o_3['t5']['events'].sel(index=t6)
	t3 = o_3['t5']['games'].to_dataframe().iloc[-2].to_dict()
	pprint.pprint(t3)
	assert t3['gamePk'] == 634280

	t7 = 'https://www.youtube.com/watch?v=T0MUK91ZWys'

	return dict(
		t2=t2,
		t3=t3,
		t4=t4,
		t7=t7,
	)


def kernel_5(o_4):
	for o in [o_4['t4'], o_4['t7']]:
		subprocess.check_call(
			[
				'youtube-dl',
				'-f',
				'18',
				o,
			]
		)


def kernel_12():
	import easyocr

	t6 = easyocr.Reader(['en'])

	return dict(
		t6=t6,
	)


def kernel_6(
	o_7=None,
	o_10=None,
	o_12=None,
	max_frames=None,
):
	if max_frames is None:
		max_frames = 10

	import tqdm
	import cv2

	t1 = glob.glob('*.mp4')

	t8 = []
	for o in t1:
		t7 = []
		t2 = None
		try:
			t2 = cv2.VideoCapture(o)
			for k in tqdm.tqdm(range(max_frames)):
				t3 = t2.read()
				assert t3[0]
				t4 = t3[1]
				if not o_12 is None:
					t5 = o_12['t6'].readtext(t4)
				else:
					t5 = None

				if not o_7 is None:
					t10 = o_7['estimate_pose'](t4)
				else:
					t10 = None
				if not o_10 is None:
					t11 = o_10['model'](t4).pandas().xywhn
				else:
					t11 = None

				t7.append(
					dict(
						frame_id=k,
						t5=t5,
						t10=t10,
						t11=t11,
					),
				)
		finally:
			if not t2 is None:
				t2.release()
		t8.append(
			dict(
				video_path=o,
				frames=t7,
			)
		)

	t9 = []
	for o in t1:
		cap = None

		try:
			cap = cv2.VideoCapture(o)
			fps = cap.get(cv2.CAP_PROP_FPS)  # OpenCV2 version 2 used "CV_CAP_PROP_FPS"
			frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
			duration = frame_count / fps
		finally:
			if not cap is None:
				cap.release()

		t9.append(
			dict(
				video_path=o,
				fps=fps,
				frame_count=frame_count,
				duration=duration,
			)
		)

	return dict(
		t8=t8,
		t9=t9,
	)


def kernel_7(
	use_gpu=None,
):
	#!/usr/bin/env python
	# coding: utf-8

	#
	#
	# NOTE: Turn on Internet and GPU

	# The code hidden below handles all the imports and function definitions (the heavy lifting). If you're a beginner I'd advice you skip this for now. When you are able to understand the rest of the code, come back here and understand each function to get a deeper knowledge.

	# In[1]:

	# !/usr/bin/env python3
	# coding=utf-8
	# author=dave.fang@outlook.com
	# create=20171225

	import os
	import pprint
	import cv2
	import sys
	import math
	import time
	import tempfile
	import numpy as np
	import matplotlib.pyplot as plt

	import torch
	import torch.nn as nn
	import torch.nn.parallel
	import torch.backends.cudnn as cudnn
	import torch.optim as optim
	import torchvision.transforms as transforms
	import torchvision.datasets as datasets
	import torchvision.models

	from torch.autograd import Variable

	from scipy.ndimage.filters import gaussian_filter

	# get_ipython().run_line_magic('matplotlib', 'inline')
	# get_ipython().run_line_magic('config', "InlineBackend.figure_format = 'retina'")

	# find connection in the specified sequence, center 29 is in the position 15
	limb_seq = [
		[2, 3],
		[2, 6],
		[3, 4],
		[4, 5],
		[6, 7],
		[7, 8],
		[2, 9],
		[9, 10],
		[10, 11],
		[2, 12],
		[12, 13],
		[13, 14],
		[2, 1],
		[1, 15],
		[15, 17],
		[1, 16],
		[16, 18],
		[3, 17],
		[6, 18],
	]

	# the middle joints heatmap correpondence
	map_ids = [
		[31, 32],
		[39, 40],
		[33, 34],
		[35, 36],
		[41, 42],
		[43, 44],
		[19, 20],
		[21, 22],
		[23, 24],
		[25, 26],
		[27, 28],
		[29, 30],
		[47, 48],
		[49, 50],
		[53, 54],
		[51, 52],
		[55, 56],
		[37, 38],
		[45, 46],
	]

	# these are the colours for the 18 body points
	colors = [
		[255, 0, 0],
		[255, 85, 0],
		[255, 170, 0],
		[255, 255, 0],
		[170, 255, 0],
		[85, 255, 0],
		[0, 255, 0],
		[0, 255, 85],
		[0, 255, 170],
		[0, 255, 255],
		[0, 170, 255],
		[0, 85, 255],
		[0, 0, 255],
		[85, 0, 255],
		[170, 0, 255],
		[255, 0, 255],
		[255, 0, 170],
		[255, 0, 85],
	]

	class PoseEstimation(nn.Module):
		def __init__(self, model_dict):
			super(PoseEstimation, self).__init__()

			self.model0 = model_dict['block_0']
			self.model1_1 = model_dict['block1_1']
			self.model2_1 = model_dict['block2_1']
			self.model3_1 = model_dict['block3_1']
			self.model4_1 = model_dict['block4_1']
			self.model5_1 = model_dict['block5_1']
			self.model6_1 = model_dict['block6_1']

			self.model1_2 = model_dict['block1_2']
			self.model2_2 = model_dict['block2_2']
			self.model3_2 = model_dict['block3_2']
			self.model4_2 = model_dict['block4_2']
			self.model5_2 = model_dict['block5_2']
			self.model6_2 = model_dict['block6_2']

		def forward(self, x):
			out1 = self.model0(x)

			out1_1 = self.model1_1(out1)
			out1_2 = self.model1_2(out1)
			out2 = torch.cat([out1_1, out1_2, out1], 1)

			out2_1 = self.model2_1(out2)
			out2_2 = self.model2_2(out2)
			out3 = torch.cat([out2_1, out2_2, out1], 1)

			out3_1 = self.model3_1(out3)
			out3_2 = self.model3_2(out3)
			out4 = torch.cat([out3_1, out3_2, out1], 1)

			out4_1 = self.model4_1(out4)
			out4_2 = self.model4_2(out4)
			out5 = torch.cat([out4_1, out4_2, out1], 1)

			out5_1 = self.model5_1(out5)
			out5_2 = self.model5_2(out5)
			out6 = torch.cat([out5_1, out5_2, out1], 1)

			out6_1 = self.model6_1(out6)
			out6_2 = self.model6_2(out6)

			return out6_1, out6_2

	def make_layers(layer_dict):
		layers = []

		for i in range(len(layer_dict) - 1):
			layer = layer_dict[i]
			for k in layer:
				v = layer[k]
				if 'pool' in k:
					layers += [nn.MaxPool2d(kernel_size=v[0], stride=v[1], padding=v[2])]
				else:
					conv2d = nn.Conv2d(in_channels=v[0], out_channels=v[1], kernel_size=v[2], stride=v[3], padding=v[4])
					layers += [conv2d, nn.ReLU(inplace=True)]
		layer = list(layer_dict[-1].keys())
		k = layer[0]
		v = layer_dict[-1][k]

		conv2d = nn.Conv2d(in_channels=v[0], out_channels=v[1], kernel_size=v[2], stride=v[3], padding=v[4])
		layers += [conv2d]

		return nn.Sequential(*layers)

	def get_pose_model():
		blocks = {}

		block_0 = [
			{'conv1_1': [3, 64, 3, 1, 1]},
			{'conv1_2': [64, 64, 3, 1, 1]},
			{'pool1_stage1': [2, 2, 0]},
			{'conv2_1': [64, 128, 3, 1, 1]},
			{'conv2_2': [128, 128, 3, 1, 1]},
			{'pool2_stage1': [2, 2, 0]},
			{'conv3_1': [128, 256, 3, 1, 1]},
			{'conv3_2': [256, 256, 3, 1, 1]},
			{'conv3_3': [256, 256, 3, 1, 1]},
			{'conv3_4': [256, 256, 3, 1, 1]},
			{'pool3_stage1': [2, 2, 0]},
			{'conv4_1': [256, 512, 3, 1, 1]},
			{'conv4_2': [512, 512, 3, 1, 1]},
			{'conv4_3_CPM': [512, 256, 3, 1, 1]},
			{'conv4_4_CPM': [256, 128, 3, 1, 1]},
		]

		blocks['block1_1'] = [
			{'conv5_1_CPM_L1': [128, 128, 3, 1, 1]},
			{'conv5_2_CPM_L1': [128, 128, 3, 1, 1]},
			{'conv5_3_CPM_L1': [128, 128, 3, 1, 1]},
			{'conv5_4_CPM_L1': [128, 512, 1, 1, 0]},
			{'conv5_5_CPM_L1': [512, 38, 1, 1, 0]},
		]

		blocks['block1_2'] = [
			{'conv5_1_CPM_L2': [128, 128, 3, 1, 1]},
			{'conv5_2_CPM_L2': [128, 128, 3, 1, 1]},
			{'conv5_3_CPM_L2': [128, 128, 3, 1, 1]},
			{'conv5_4_CPM_L2': [128, 512, 1, 1, 0]},
			{'conv5_5_CPM_L2': [512, 19, 1, 1, 0]},
		]

		for i in range(2, 7):
			blocks['block%d_1' % i] = [
				{'Mconv1_stage%d_L1' % i: [185, 128, 7, 1, 3]},
				{'Mconv2_stage%d_L1' % i: [128, 128, 7, 1, 3]},
				{'Mconv3_stage%d_L1' % i: [128, 128, 7, 1, 3]},
				{'Mconv4_stage%d_L1' % i: [128, 128, 7, 1, 3]},
				{'Mconv5_stage%d_L1' % i: [128, 128, 7, 1, 3]},
				{'Mconv6_stage%d_L1' % i: [128, 128, 1, 1, 0]},
				{'Mconv7_stage%d_L1' % i: [128, 38, 1, 1, 0]},
			]
			blocks['block%d_2' % i] = [
				{'Mconv1_stage%d_L2' % i: [185, 128, 7, 1, 3]},
				{'Mconv2_stage%d_L2' % i: [128, 128, 7, 1, 3]},
				{'Mconv3_stage%d_L2' % i: [128, 128, 7, 1, 3]},
				{'Mconv4_stage%d_L2' % i: [128, 128, 7, 1, 3]},
				{'Mconv5_stage%d_L2' % i: [128, 128, 7, 1, 3]},
				{'Mconv6_stage%d_L2' % i: [128, 128, 1, 1, 0]},
				{'Mconv7_stage%d_L2' % i: [128, 19, 1, 1, 0]},
			]

		layers = []
		for block in block_0:
			# print(block)
			for key in block:
				v = block[key]
				if 'pool' in key:
					layers += [nn.MaxPool2d(kernel_size=v[0], stride=v[1], padding=v[2])]
				else:
					conv2d = nn.Conv2d(in_channels=v[0], out_channels=v[1], kernel_size=v[2], stride=v[3], padding=v[4])
					layers += [conv2d, nn.ReLU(inplace=True)]

		models = {'block_0': nn.Sequential(*layers)}

		for k in blocks:
			v = blocks[k]
			models[k] = make_layers(v)

		return PoseEstimation(models)

	def get_paf_and_heatmap(model, img_raw, scale_search, param_stride=8, box_size=368):
		multiplier = [scale * box_size / img_raw.shape[0] for scale in scale_search]

		heatmap_avg = torch.zeros((len(multiplier), 19, img_raw.shape[0], img_raw.shape[1])).cuda()
		paf_avg = torch.zeros((len(multiplier), 38, img_raw.shape[0], img_raw.shape[1])).cuda()

		for i, scale in enumerate(multiplier):
			img_test = cv2.resize(img_raw, (0, 0), fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC)
			img_test_pad, pad = pad_right_down_corner(img_test, param_stride, param_stride)
			img_test_pad = np.transpose(np.float32(img_test_pad[:, :, :, np.newaxis]), (3, 2, 0, 1)) / 256 - 0.5

			feed = Variable(torch.from_numpy(img_test_pad)).cuda()
			output1, output2 = model(feed)

			# print(output1.size())
			# print(output2.size())

			heatmap = nn.UpsamplingBilinear2d((img_raw.shape[0], img_raw.shape[1])).cuda()(output2)

			paf = nn.UpsamplingBilinear2d((img_raw.shape[0], img_raw.shape[1])).cuda()(output1)

			heatmap_avg[i] = heatmap[0].data
			paf_avg[i] = paf[0].data

		heatmap_avg = torch.transpose(torch.transpose(torch.squeeze(torch.mean(heatmap_avg, 0)), 0, 1), 1, 2).cuda()
		heatmap_avg = heatmap_avg.cpu().numpy()

		paf_avg = torch.transpose(torch.transpose(torch.squeeze(torch.mean(paf_avg, 0)), 0, 1), 1, 2).cuda()
		paf_avg = paf_avg.cpu().numpy()

		return paf_avg, heatmap_avg

	def extract_heatmap_info(heatmap_avg, param_thre1=0.1):
		all_peaks = []
		peak_counter = 0

		for part in range(18):
			map_ori = heatmap_avg[:, :, part]
			map_gau = gaussian_filter(map_ori, sigma=3)

			map_left = np.zeros(map_gau.shape)
			map_left[1:, :] = map_gau[:-1, :]
			map_right = np.zeros(map_gau.shape)
			map_right[:-1, :] = map_gau[1:, :]
			map_up = np.zeros(map_gau.shape)
			map_up[:, 1:] = map_gau[:, :-1]
			map_down = np.zeros(map_gau.shape)
			map_down[:, :-1] = map_gau[:, 1:]

			peaks_binary = np.logical_and.reduce((map_gau >= map_left, map_gau >= map_right, map_gau >= map_up, map_gau >= map_down, map_gau > param_thre1))

			peaks = zip(np.nonzero(peaks_binary)[1], np.nonzero(peaks_binary)[0])  # note reverse
			peaks = list(peaks)
			peaks_with_score = [x + (map_ori[x[1], x[0]],) for x in peaks]
			ids = range(peak_counter, peak_counter + len(peaks))
			peaks_with_score_and_id = [peaks_with_score[i] + (ids[i],) for i in range(len(ids))]

			all_peaks.append(peaks_with_score_and_id)
			peak_counter += len(peaks)

		return all_peaks

	def extract_paf_info(img_raw, paf_avg, all_peaks, param_thre2=0.05, param_thre3=0.5):
		connection_all = []
		special_k = []
		mid_num = 10

		for k in range(len(map_ids)):
			score_mid = paf_avg[:, :, [x - 19 for x in map_ids[k]]]
			candA = all_peaks[limb_seq[k][0] - 1]
			candB = all_peaks[limb_seq[k][1] - 1]
			nA = len(candA)
			nB = len(candB)
			if nA != 0 and nB != 0:
				connection_candidate = []
				for i in range(nA):
					for j in range(nB):
						vec = np.subtract(candB[j][:2], candA[i][:2])
						norm = math.sqrt(vec[0] * vec[0] + vec[1] * vec[1])
						if norm < 1e-8:
							raise ZeroDivisionError
						vec = np.divide(vec, norm)

						startend = zip(np.linspace(candA[i][0], candB[j][0], num=mid_num), np.linspace(candA[i][1], candB[j][1], num=mid_num))
						startend = list(startend)

						vec_x = np.array([score_mid[int(round(startend[I][1])), int(round(startend[I][0])), 0] for I in range(len(startend))])
						vec_y = np.array([score_mid[int(round(startend[I][1])), int(round(startend[I][0])), 1] for I in range(len(startend))])

						score_midpts = np.multiply(vec_x, vec[0]) + np.multiply(vec_y, vec[1])
						score_with_dist_prior = sum(score_midpts) / len(score_midpts)
						score_with_dist_prior += min(0.5 * img_raw.shape[0] / norm - 1, 0)

						criterion1 = len(np.nonzero(score_midpts > param_thre2)[0]) > 0.8 * len(score_midpts)
						criterion2 = score_with_dist_prior > 0
						if criterion1 and criterion2:
							connection_candidate.append([i, j, score_with_dist_prior, score_with_dist_prior + candA[i][2] + candB[j][2]])

				connection_candidate = sorted(connection_candidate, key=lambda x: x[2], reverse=True)
				connection = np.zeros((0, 5))
				for c in range(len(connection_candidate)):
					i, j, s = connection_candidate[c][0:3]
					if i not in connection[:, 3] and j not in connection[:, 4]:
						connection = np.vstack([connection, [candA[i][3], candB[j][3], s, i, j]])
						if len(connection) >= min(nA, nB):
							break

				connection_all.append(connection)
			else:
				special_k.append(k)
				connection_all.append([])

		return special_k, connection_all

	def get_subsets(connection_all, special_k, all_peaks):
		# last number in each row is the total parts number of that person
		# the second last number in each row is the score of the overall configuration
		subset = -1 * np.ones((0, 20))
		candidate = np.array([item for sublist in all_peaks for item in sublist])

		for k in range(len(map_ids)):
			if k not in special_k:
				partAs = connection_all[k][:, 0]
				partBs = connection_all[k][:, 1]
				indexA, indexB = np.array(limb_seq[k]) - 1

				for i in range(len(connection_all[k])):  # = 1:size(temp,1)
					found = 0
					subset_idx = [-1, -1]
					for j in range(len(subset)):  # 1:size(subset,1):
						if subset[j][indexA] == partAs[i] or subset[j][indexB] == partBs[i]:
							subset_idx[found] = j
							found += 1

					if found == 1:
						j = subset_idx[0]
						if subset[j][indexB] != partBs[i]:
							subset[j][indexB] = partBs[i]
							subset[j][-1] += 1
							subset[j][-2] += candidate[partBs[i].astype(int), 2] + connection_all[k][i][2]
					elif found == 2:  # if found 2 and disjoint, merge them
						j1, j2 = subset_idx
						print('found = 2')
						membership = ((subset[j1] >= 0).astype(int) + (subset[j2] >= 0).astype(int))[:-2]
						if len(np.nonzero(membership == 2)[0]) == 0:  # merge
							subset[j1][:-2] += subset[j2][:-2] + 1
							subset[j1][-2:] += subset[j2][-2:]
							subset[j1][-2] += connection_all[k][i][2]
							subset = np.delete(subset, j2, 0)
						else:  # as like found == 1
							subset[j1][indexB] = partBs[i]
							subset[j1][-1] += 1
							subset[j1][-2] += candidate[partBs[i].astype(int), 2] + connection_all[k][i][2]

					# if find no partA in the subset, create a new subset
					elif not found and k < 17:
						row = -1 * np.ones(20)
						row[indexA] = partAs[i]
						row[indexB] = partBs[i]
						row[-1] = 2
						row[-2] = sum(candidate[connection_all[k][i, :2].astype(int), 2]) + connection_all[k][i][2]
						subset = np.vstack([subset, row])
		return subset, candidate

	def draw_key_point(subset, all_peaks, img_raw):
		del_ids = []
		for i in range(len(subset)):
			if subset[i][-1] < 4 or subset[i][-2] / subset[i][-1] < 0.4:
				del_ids.append(i)
		subset = np.delete(subset, del_ids, axis=0)

		img_canvas = img_raw.copy()  # B,G,R order

		for i in range(18):
			for j in range(len(all_peaks[i])):
				cv2.circle(img_canvas, all_peaks[i][j][0:2], 4, colors[i], thickness=-1)

		return subset, img_canvas

	def link_key_point(img_canvas, candidate, subset, stickwidth=4):
		for i in range(17):
			for n in range(len(subset)):
				index = subset[n][np.array(limb_seq[i]) - 1]
				if -1 in index:
					continue
				cur_canvas = img_canvas.copy()
				Y = candidate[index.astype(int), 0]
				X = candidate[index.astype(int), 1]
				mX = np.mean(X)
				mY = np.mean(Y)
				length = ((X[0] - X[1]) ** 2 + (Y[0] - Y[1]) ** 2) ** 0.5
				angle = math.degrees(math.atan2(X[0] - X[1], Y[0] - Y[1]))
				polygon = cv2.ellipse2Poly((int(mY), int(mX)), (int(length / 2), stickwidth), int(angle), 0, 360, 1)
				cv2.fillConvexPoly(cur_canvas, polygon, colors[i])
				img_canvas = cv2.addWeighted(img_canvas, 0.4, cur_canvas, 0.6, 0)

		return img_canvas

	def pad_right_down_corner(img, stride, pad_value):
		h = img.shape[0]
		w = img.shape[1]

		pad = 4 * [None]
		pad[0] = 0  # up
		pad[1] = 0  # left
		pad[2] = 0 if (h % stride == 0) else stride - (h % stride)  # down
		pad[3] = 0 if (w % stride == 0) else stride - (w % stride)  # right

		img_padded = img
		pad_up = np.tile(img_padded[0:1, :, :] * 0 + pad_value, (pad[0], 1, 1))
		img_padded = np.concatenate((pad_up, img_padded), axis=0)
		pad_left = np.tile(img_padded[:, 0:1, :] * 0 + pad_value, (1, pad[1], 1))
		img_padded = np.concatenate((pad_left, img_padded), axis=1)
		pad_down = np.tile(img_padded[-2:-1, :, :] * 0 + pad_value, (pad[2], 1, 1))
		img_padded = np.concatenate((img_padded, pad_down), axis=0)
		pad_right = np.tile(img_padded[:, -2:-1, :] * 0 + pad_value, (1, pad[3], 1))
		img_padded = np.concatenate((img_padded, pad_right), axis=1)

		return img_padded, pad

	if __name__ == '__main__':
		print(get_pose_model())

	# First let's download the pre-trained model.

	# In[2]:

	# Using gdown to download the model directly from Google Drive

	# assert os.system(' conda install -y gdown') == 0
	import gdown

	# In[3]:

	model = 'coco_pose_iter_440000.pth.tar'
	if not os.path.exists(model):
		url = 'https://drive.google.com/u/0/uc?export=download&confirm=f_Ix&id=0B1asvDK18cu_MmY1ZkpaOUhhRHM'
		gdown.download(url, model, quiet=False)

	# In[4]:

	state_dict = torch.load(model)['state_dict']  # getting the pre-trained model's parameters
	# A state_dict is simply a Python dictionary object that maps each layer to its parameter tensor.

	model_pose = get_pose_model()  # building the model (see fn. defn. above). To see the architecture, see below cell.
	model_pose.load_state_dict(state_dict)  # Loading the parameters (weights, biases) into the model.

	model_pose.float()  # I'm not sure why this is used. No difference if you remove it.

	if use_gpu is None:
		use_gpu = True

	if use_gpu:
		model_pose.cuda()
		model_pose = torch.nn.DataParallel(model_pose, device_ids=range(torch.cuda.device_count()))
		cudnn.benchmark = True

	def estimate_pose(
		img_ori,
		name=None,
		scale_param=None,
		display=None,
	):
		if display is None:
			display = True

		if scale_param is None:
			scale_param = [0.5, 1.0, 1.5, 2.0]

		if display:
			if name is None:
				name = tempfile.mktemp(
					dir='/kaggle/working',
					suffix='.png',
				)
			pprint.pprint(
				['estimate_pose', dict(name=name)],
			)

		# People might be at different scales in the image, perform inference at multiple scales to boost results

		# Predict Heatmaps for approximate joint position
		# Use Part Affinity Fields (PAF's) as guidance to link joints to form skeleton
		# PAF's are just unit vectors along the limb encoding the direction of the limb
		# A dot product of possible joint connection will be high if actual limb else low

		img_canvas = None
		img_points = None

		try:
			paf_info, heatmap_info = get_paf_and_heatmap(model_pose, img_ori, scale_param)
			peaks = extract_heatmap_info(heatmap_info)
			sp_k, con_all = extract_paf_info(img_ori, paf_info, peaks)

			subsets, candidates = get_subsets(con_all, sp_k, peaks)

			subsets, img_points = draw_key_point(subsets, peaks, img_ori)
			img_canvas = link_key_point(img_points, candidates, subsets)
		except ZeroDivisionError:
			pprint.pprint('zero de')

			img_points = img_ori.copy()
			img_canvas = img_ori.copy()

		# After predicting Heatmaps and PAF's, proceeed to link joints correctly
		if display:
			f = plt.figure(figsize=(15, 10))

			plt.subplot(1, 2, 1)
			plt.imshow(img_points[..., ::-1])

			plt.subplot(1, 2, 2)
			plt.imshow(img_canvas[..., ::-1])

			f.savefig(name)

		return dict(
			img_points=img_points,
			img_canvas=img_canvas,
		)

	# In[5]:

	return dict(
		cv2=cv2,
		estimate_pose=estimate_pose,
		model_pose=model_pose,
	)


def kernel_8(
	o_7,
):
	for i, o in enumerate(['../input/indonesian-traditional-dance/tgagrakanyar/tga_00%d0.jpg' % k for k in range(6)]):
		arch_image = o
		img_ori = o_7['cv2'].imread(arch_image)
		o_7['estimate_pose'](img_ori)


def kernel_9_benchmark(
	o_7,
):
	import datetime

	t1 = o_7['cv2'].imread('../input/indonesian-traditional-dance/tgagrakanyar/tga_0000.jpg')
	t5 = 10
	t2 = datetime.datetime.now()
	for k in range(t5):
		o_7['estimate_pose'](
			img_ori=t1,
			scale_param=[1.0],
			display=False,
		)
	t3 = datetime.datetime.now()
	t4 = (t3 - t2).total_seconds() / t5
	pprint.pprint(['kernel_9_benchmark', dict(t4=t4, t5=t5)])


def kernel_10():
	import torch

	# Model
	model = torch.hub.load('ultralytics/yolov5', 'yolov5s')  # or yolov5m, yolov5x, custom

	# Images
	img = 'https://ultralytics.com/images/zidane.jpg'  # or file, PIL, OpenCV, numpy, multiple

	# Inference
	results = model(img)

	# Results
	results.print()  # or .show(), .save(), .crop(), .pandas(), etc.

	return dict(
		model=model,
	)


def kernel_11_benchmark(
	o_7,
	o_10,
):
	import datetime

	t1 = o_7['cv2'].imread('../input/indonesian-traditional-dance/tgagrakanyar/tga_0000.jpg')
	t5 = 10
	t2 = datetime.datetime.now()
	for k in range(t5):
		t6 = o_10['model'](t1)
		t7 = t6.pandas().xywhn

	t3 = datetime.datetime.now()
	t4 = (t3 - t2).total_seconds() / t5
	pprint.pprint(['kernel_11_benchmark', dict(t4=t4, t5=t5)])


def kernel_13(
	o_6=None,
):
	t2 = ['/kaggle/working', '/kaggle/input/garbage']

	t3 = [
		os.path.join(
			o,
			'kernel_13-object-detection.nc',
		)
		for o in t2
	]

	t4 = [o for o in t3 if os.path.exists(o)]

	if not len(t4) > 0 or not o_6 is None:
		t1 = pandas.concat(
			sum([[o2['t11'][0].assign(frame_id=k, video_path=o['video_path']) for k, o2 in enumerate(o['frames'])] for o in o_6['t8']], [])
		).to_xarray()
		t5 = t3[0]
		t1.to_netcdf(t5)
		del t1
	elif len(t4) > 0:
		t5 = t4[0]
	else:
		raise NotImplementedError

	t1 = xarray.load_dataset(t5)

	return dict(
		t1=t1,
	)


def kernel_14(
	skip_o_6=None,
	skip_o_7_10_12_13=None,
	run_benchmark=None,
):
	if skip_o_6 is None:
		skip_o_6 = True

	if skip_o_7_10_12_13 is None:
		skip_o_7_10_12_13 = True

	if run_benchmark is None:
		run_benchmark = False

	o_3 = kernel_3(should_exist=True)
	o_4 = kernel_4(o_3=o_3)
	o_5 = kernel_5(o_4=o_4)

	if not skip_o_7_10_12_13:
		o_7 = kernel_7()

		o_10 = kernel_10()
		o_12 = kernel_12()
	else:
		o_7 = None
		o_10 = None
		o_12 = None

	if not skip_o_6:
		o_6 = kernel_6(o_7=None, o_10=o_10, o_12=None, max_frames=10000)
	else:
		o_6 = None

	if not skip_o_7_10_12_13:
		o_13 = kernel_13(
			o_6=o_6,
		)
	else:
		o_13 = None

	if run_benchmark:
		o_11 = kernel_11_benchmark(o_7=o_7, o_10=o_10)
		o_9 = kernel_9_benchmark(o_7=o_7)
		o_8 = kernel_8(o_7=o_7)

	return dict(
		o_3=o_3,
		o_13=o_13,
		o_7=o_7,
	)


def kernel_15(
	o_14,
):
	t1 = pandas.DataFrame(numpy.unique(o_14['o_13']['t1']['name'].data, return_counts=True)).T
	pprint.pprint(
		dict(
			t1=t1,
		)
	)

	t29 = 'output-gif'
	if not os.path.exists(t29):
		os.makedirs(t29, exist_ok=True)

	for t2 in [
		'baseball glove',
		'baseball bat',
		'sports ball',
		'person',
	]:
		t28 = t2.replace(' ', '-')
		t3 = o_14['o_13']['t1']
		t4 = numpy.where(t3.name.data == t2)[0]

		t30 = 'output-png/%s' % t28
		if not os.path.exists(t30):
			os.makedirs(t30, exist_ok=True)

		numpy.random.seed(0)
		t22 = numpy.random.choice(t4, 10)
		pprint.pprint(t22)
		import tqdm

		t24 = []
		t27 = []
		for t5 in tqdm.tqdm(t22):
			t6 = t3.video_path.data[t5]
			t7 = t3.frame_id.data[t5]
			t8 = t3.to_dataframe().iloc[t5]
			# pprint.pprint([t6, t7])
			# pprint.pprint(t8)

			import cv2
			import matplotlib.pyplot

			t9 = cv2.VideoCapture(t6)
			t9.set(cv2.CAP_PROP_POS_FRAMES, t7)
			t10 = t9.read()
			t9.release()
			t11 = t10[1]
			t12 = cv2.cvtColor(t11, cv2.COLOR_BGR2RGB)
			t13 = t12.copy()
			t15 = numpy.array([t8.xcenter, t8.ycenter, t8.width, t8.height])
			t16 = numpy.array([t13.shape[1], t13.shape[0], t13.shape[1], t13.shape[0]])
			t17 = t15 * t16
			t18 = t17[:2] - t17[2:] / 2
			t19 = t17[:2] + t17[2:] / 2
			t20 = numpy.array(
				[
					t18[0],
					t18[1],
					t19[0],
					t19[1],
				]
			)
			t21 = numpy.round(t20).astype(numpy.int32)
			t14 = cv2.rectangle(
				t13,
				tuple(t21[:2]),
				tuple(t21[2:]),
				(0, 255, 0),
				1,
			)

			if False:
				t32 = o_14['o_7']['estimate_pose'](
					t12,
					scale_param=[1.0],
					display=False,
				)['img_canvas']
			else:
				t32 = kernel_16([t12])['t6'][0]

			f = matplotlib.pyplot.figure(figsize=(8, 12))
			f.suptitle(
				'name %s, frame_id %d\nvideo_path %s'
				% (
					t8['name'],
					t8.frame_id,
					t8.video_path,
				)
			)
			matplotlib.pyplot.subplot(2, 1, 1)
			matplotlib.pyplot.title('score %s' % (t8.confidence,))
			matplotlib.pyplot.imshow(t14)
			matplotlib.pyplot.subplot(2, 1, 2)
			matplotlib.pyplot.imshow(t32)
			t25 = os.path.join(
				t30,
				'kernel_15-%s-%05d.jpg'
				% (
					t28,
					t7,
				),
			)
			f.savefig(t25)
			t24.append(t25)
			matplotlib.pyplot.close(f)

			t27.append([t8, t21])
		pprint.pprint(pandas.concat([o[0] for o in t27], axis=1).T)

		t23 = os.path.join(t29, 'output-%s.gif' % t28)
		if os.path.exists(t23):
			subprocess.check_call(['rm', t23])

		subprocess.check_call(
			[
				'convert',
				'-delay',
				'100',
				'-loop',
				'0',
				*t24,
				t23,
			]
		)


def kernel_16(images):
	assert isinstance(images, list)

	import cv2
	import subprocess
	import os

	t2 = '/kaggle/working/test-input'
	subprocess.check_call(
		[
			'rm',
			'-fr',
			t2,
		]
	)

	subprocess.check_call(
		[
			'mkdir',
			'-p',
			t2,
		]
	)

	t1 = []
	for i, o in enumerate(images):
		t5 = cv2.cvtColor(o, cv2.COLOR_RGB2BGR)
		t8 = 'image-%d.jpg' % i
		t3 = os.path.join(
			t2,
			t8,
		)
		cv2.imwrite(t3, t5)
		t1.append(
			dict(
				image_name=t8,
				image_path=t3,
				image_canvas=o,
				image_index=i,
			)
		)

	t4 = '/kaggle/working/test-output'
	subprocess.check_call(
		[
			'rm',
			'-fr',
			t4,
		]
	)

	subprocess.check_call(
		[
			'mkdir',
			'-p',
			t4,
		]
	)

	with subprocess.Popen(
		"""
        cd /kaggle/working/AlphaPose &&
        python3 \
            scripts/demo_inference.py \
            --cfg configs/coco/resnet/256x192_res50_lr1e-3_1x.yaml \
            --checkpoint pretrained_models/fast_res50_256x192.pth \
            --indir %s \
            --outdir %s \
            --save_img
    """
		% (t2, t4),
		shell=True,
		stdout=subprocess.PIPE,
		stderr=subprocess.PIPE,
	) as p:
		pprint.pprint(p.communicate())
		p.wait()
		assert p.returncode == 0

	t6 = []
	with io.open(os.path.join(t4, 'alphapose-results.json'), 'r') as f:
		t7 = json.load(f)
	for o in t1:
		t9 = os.path.join(t4, 'vis', o['image_name'])
		assert os.path.exists(t9)
		t10 = cv2.imread(t9, cv2.IMREAD_COLOR)
		t11 = cv2.cvtColor(t10, cv2.COLOR_BGR2RGB)
		t6.append(t11)
	return dict(
		images=images,
		t1=t1,
		t6=t6,
		t7=t7,
	)


def kernel_17(
	o_14,
	max_images=None,
):
	if max_images is None:
		max_images = 10

	t50 = []
	for t2 in [
		'baseball glove',
		'baseball bat',
		'sports ball',
		'person',
	]:
		t28 = t2.replace(' ', '-')
		t3 = o_14['o_13']['t1']
		t4 = numpy.where(t3.name.data == t2)[0]

		t30 = 'output-png/%s' % t28
		if not os.path.exists(t30):
			os.makedirs(t30, exist_ok=True)

		numpy.random.seed(0)
		t22 = numpy.random.choice(t4, max_images)
		pprint.pprint(t22)
		import tqdm

		t24 = []
		t27 = []
		for t5 in tqdm.tqdm(t22):
			t6 = t3.video_path.data[t5]
			t7 = t3.frame_id.data[t5]
			t8 = t3.to_dataframe().iloc[t5]
			# pprint.pprint([t6, t7])
			# pprint.pprint(t8)

			import cv2
			import matplotlib.pyplot

			t9 = cv2.VideoCapture(t6)
			t9.set(cv2.CAP_PROP_POS_FRAMES, t7)
			t10 = t9.read()
			t9.release()
			t11 = t10[1]
			t12 = cv2.cvtColor(t11, cv2.COLOR_BGR2RGB)
			t13 = t12.copy()

			t50.append(
				dict(
					t2=t2,
					t28=t28,
					t6=t6,
					t5=t5,
					t7=t7,
					t12=t12,
				)
			)

	return dict(
		t50=t50,
	)


def kernel_18(o_17):
	t1 = [o['t12'] for o in o_17['t50']]
	t2 = kernel_16(t1)

	return dict(
		t2=t2,
	)


def kernel_19(o_18):
	kernel_25(o_18['t2']['t6'])


def kernel_20(
	o_18,
	o_21=None,
):
	if o_21 is None:
		o_21 = kernel_21()

	import cv2
	import numpy
	import os

	t1 = numpy.array(o_18['t2']['t7'][0]['keypoints']).reshape(17, -1)
	t2 = o_18['t2']['t6'][0]
	t3 = o_18['t2']['t1'][0]['image_canvas'].copy()
	assert o_18['t2']['t7'][0]['image_id'] == os.path.split(o_18['t2']['t1'][0]['image_name'])[1]

	for i, o2 in enumerate(o_21['p_color']):
		if i >= 17:
			print('fuck %d' % i)
			continue
		o1 = t1[i, :]
		cv2.circle(t3, tuple(o1[:2].astype(numpy.int32)), 3, o2, -1)
	cv2.imwrite('output.jpg', cv2.cvtColor(t3, cv2.COLOR_RGB2BGR))
	cv2.imwrite('output-v2.jpg', cv2.cvtColor(t2, cv2.COLOR_RGB2BGR))


def kernel_21():
	l_pair = [
		(0, 1),
		(0, 2),
		(1, 3),
		(2, 4),  # Head
		(5, 6),
		(5, 7),
		(7, 9),
		(6, 8),
		(8, 10),
		(17, 11),
		(17, 12),  # Body
		(11, 13),
		(12, 14),
		(13, 15),
		(14, 16),
	]
	p_color = [
		# Nose, LEye, REye, LEar, REar
		(0, 255, 255),
		(0, 191, 255),
		(0, 255, 102),
		(0, 77, 255),
		(0, 255, 0),
		# LShoulder, RShoulder, LElbow, RElbow, LWrist, RWrist
		(77, 255, 255),
		(77, 255, 204),
		(77, 204, 255),
		(191, 255, 77),
		(77, 191, 255),
		(191, 255, 77),
		# LHip, RHip, LKnee, Rknee, LAnkle, RAnkle
		(204, 77, 255),
		(77, 255, 204),
		(191, 77, 255),
		(77, 255, 191),
		(127, 77, 255),
		(77, 255, 127),
		# Not Present
		## Neck
		# (0, 255, 255),
	]

	line_color = [
		(0, 215, 255),
		(0, 255, 204),
		(0, 134, 255),
		(0, 255, 50),
		(77, 255, 222),
		(77, 196, 255),
		(77, 135, 255),
		(191, 255, 77),
		(77, 255, 77),
		(77, 222, 255),
		(255, 156, 127),
		(0, 127, 255),
		(255, 127, 77),
		(0, 77, 255),
		(255, 77, 36),
	]
	# https://debuggercafe.com/wp-content/uploads/2020/10/keypoint_exmp.jpg
	# Seems like No Neck actually
	title = [
		'Nose',
		'LEye',
		'REye',
		'LEar',
		'REar',
		'LShoulder',
		'RShoulder',
		'LElbow',
		'RElbow',
		'LWrist',
		'RWrist',
		'LHip',
		'RHip',
		'LKnee',
		'RKnee',
		'LAnkle',
		'RAnkle',
		#'Neck',
	]

	return dict(
		l_pair=l_pair,
		p_color=p_color,
		line_color=line_color,
	)


def kernel_22(o_18):
	t1 = o_18['t2']['t7']
	t2 = [numpy.array(o['keypoints']).reshape(17, 3) for o in t1]

	o_31 = kernel_31(
		image_id=[o['image_id'] for o in t1],
		image_size=numpy.array([[list(o['image_canvas'].shape) for o in o_18['t2']['t1'] if o['image_name'] == t1[i]['image_id']][0] for i in range(len(t2))]),
		keypoints=numpy.stack(t2, axis=0),
	)
	t12 = o_31['t12']

	return dict(
		t4=t12,
	)


def kernel_24(
	img,
	keypoints,
	o_21=None,
):
	t3 = img.copy()

	if o_21 is None:
		o_21 = kernel_21()

	import cv2
	import numpy
	import os

	for i, o2 in enumerate(o_21['p_color']):
		if i >= 17:
			print('fuck %d' % i)
			continue
		o1 = keypoints[i, :]
		cv2.circle(t3, tuple(o1[:2].astype(numpy.int32)), 3, o2, -1)

	return dict(
		t3=t3,
	)


def kernel_25(images, delay=None):
	if delay is None:
		delay = 100

	import tqdm
	import os
	import cv2
	import subprocess

	if len(images) == 0:
		pprint.pprint(['kernel_25', 'no images'])
		return

	t3 = 'kernel_25-output.dir'
	os.makedirs(t3, exist_ok=True)
	t6 = []
	for i, o in tqdm.tqdm(enumerate(images)):
		t4 = 'image-%03d.jpg' % i
		t5 = os.path.join(t3, t4)
		t8 = cv2.cvtColor(o, cv2.COLOR_RGB2BGR)
		cv2.imwrite(t5, t8)
		t6.append(t5)

	t7 = os.path.join(t3, 'output.gif')

	if False:
		subprocess.check_call(
			[
				'convert',
				'-delay',
				'%d' % delay,
				'-loop',
				'0',
				*t6,
				t7,
			]
		)

	t8 = os.path.join(
		t3,
		'output.mp4',
	)
	if os.path.exists(t8):
		os.unlink(t8)

	if False:
		subprocess.check_call(
			[
				'ffmpeg',
				'-i',
				t7,
				t8,
			]
		)
	t9 = os.path.join(t3, 'input.txt')

	with io.open(t9, 'w') as f:
		f.write('\n'.join(['file %s' % os.path.split(o)[1] for o in t6]))
	subprocess.check_call(
		[
			'ffmpeg',
			'-r',
			'%d' % int(100 / delay),
			'-f',
			'concat',
			'-i',
			'%s' % t9,
			t8,
		]
	)


def kernel_26(o_18, image_name):
	t1 = [i for i, o in enumerate(o_18['t2']['t1']) if o['image_name'] == image_name]
	assert len(t1) == 1
	return t1[0]


def kernel_23(o_18, o_22, ids=None):
	import numpy
	import tqdm

	if ids is None:
		ids = numpy.s_[:]

	t1 = numpy.arange(len(o_22['t4']))
	t2 = t1[ids]

	pprint.pprint(t2[:5])
	t7 = []
	for o in tqdm.tqdm(t2):
		t3 = o_22['t4'][o]
		t9 = kernel_26(o_18=o_18, image_name=t3['image_name'])
		t4 = o_18['t2']['t1'][t9]['image_canvas']
		t10 = o_18['t2']['t6'][t9]
		t4 = [o['image_canvas'] for o in o_18['t2']['t1'] if o['image_name'] == t3['image_name']]
		assert len(t4) == 1
		t5 = t4[0]
		t6 = kernel_24(t5, t3['keypoints'])
		t7.append(t6['t3'])
		t7.append(t10)

	kernel_25(t7)


def kernel_27():
	import tqdm
	import os
	import subprocess
	import pprint

	t5 = '/kaggle/working/ATL AT TOR - April 19, 2015-T0MUK91ZWys.mp4'
	t3 = '/kaggle/working/kernel_27-output.dir'
	os.makedirs(t3, exist_ok=True)
	# R = int(round(30 / 5))
	FRAMERATE = 4
	SLICE_LENGTH = 5 * 6
	for i in tqdm.tqdm(range(100)):
		t1 = [SLICE_LENGTH * i, SLICE_LENGTH * (i + 1)]
		t2 = os.path.join(t3, 'slice-%d' % i)
		os.makedirs(t2, exist_ok=True)
		t4 = os.path.join(t2, 'output.mp4')
		if os.path.exists(t4):
			os.unlink(t4)
		with subprocess.Popen(
			[
				'ffmpeg',
				'-i',
				'%s' % t5,
				'-filter:v',
				'fps=fps=%d' % FRAMERATE,
				'-ss',
				'%d' % t1[0],
				'-t',
				'%d' % (t1[1] - t1[0]),
				'%s' % t4,
			],
			stdout=subprocess.PIPE,
			stderr=subprocess.PIPE,
		) as p:
			if False:
				pprint.pprint(p.communicate())
			p.wait()
			assert p.returncode == 0

		t6 = """
            cd /kaggle/working/AlphaPose && \
            python3 \
                scripts/demo_inference.py \
                --cfg configs/coco/resnet/256x192_res50_lr1e-3_1x.yaml \
                --checkpoint pretrained_models/fast_res50_256x192.pth \
                --video %s \
                --outdir %s
        """ % (t4, t2)
		if False:
			pprint.pprint([t4, t2, t6])
		with subprocess.Popen(t6, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as p:
			if False:
				pprint.pprint(p.communicate())
			p.wait()
			assert p.returncode == 0


def kernel_28(
	video_path=None,
	framerate=None,
	max_seconds=None,
	video_id=None,
):
	if video_id is None:
		video_id = ''

	import cv2
	import tqdm
	import os
	import subprocess
	import pprint

	if framerate is None:
		framerate = 4
	if max_seconds is None:
		max_seconds = 999999

	if video_path is None:
		video_path = '/kaggle/working/ATL AT TOR - April 19, 2015-T0MUK91ZWys.mp4'
	t5 = video_path
	t3 = '/kaggle/working/kernel_28-output%s.dir' % video_id
	t13 = '/root/kernel_28-output.dir/tmp-slice'
	os.makedirs(t3, exist_ok=True)

	cap = None

	try:
		cap = cv2.VideoCapture(t5)
		fps = cap.get(cv2.CAP_PROP_FPS)  # OpenCV2 version 2 used "CV_CAP_PROP_FPS"
		frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
		real_duration = frame_count / fps
		duration = min(real_duration, max_seconds)
		pprint.pprint(
			dict(
				fps=fps,
				frame_count=frame_count,
				duration=duration,
				real_duration=real_duration,
			)
		)

		# R = int(round(30 / 5))
		FRAMERATE = framerate
		SLICE_LENGTH = 5 * 6
		for i in tqdm.tqdm(range(int(duration / SLICE_LENGTH + 1e-8))):
			t2 = os.path.join(t3, 'slice-%d' % i)
			if os.path.exists(t2):
				pprint.pprint(['t2', t2, 'exists', 'continue'])
				continue

			t1 = [SLICE_LENGTH * i, SLICE_LENGTH * (i + 1)]

			if os.path.exists(t13):
				subprocess.check_call(['rm', '-fr', t13])
			os.makedirs(t13, exist_ok=True)

			t8 = numpy.array([t1[0] * fps, t1[1] * fps]).astype(numpy.int32)
			cap.set(cv2.CAP_PROP_POS_FRAMES, t8[0])
			t12 = numpy.arange(t8[0], t8[1], SLICE_LENGTH * FRAMERATE)
			for k in range(t8[1] - t8[0]):
				ret, frame = cap.read()
				t11 = cap.get(cv2.CAP_PROP_POS_FRAMES)
				if numpy.isin(t11, t12):
					t10 = os.path.join(
						t13,
						'frame-%d.jpg' % t11,
					)
					cv2.imwrite(t10, frame)

			os.makedirs(t2, exist_ok=True)

			t6 = """
                cd /kaggle/working/AlphaPose && \
                python3 \
                    scripts/demo_inference.py \
                    --cfg configs/coco/resnet/256x192_res50_lr1e-3_1x.yaml \
                    --checkpoint pretrained_models/fast_res50_256x192.pth \
                    --indir %s \
                    --outdir %s
            """ % (t13, t2)
			if False:
				pprint.pprint(
					[
						# t4,
						t2,
						t6,
					]
				)
			with subprocess.Popen(t6, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as p:
				if False:
					pprint.pprint(p.communicate())
				p.wait()
				assert p.returncode == 0
	finally:
		if not cap is None:
			cap.release()


def kernel_29(
	video_path=None,
	video_id=None,
):
	if video_id is None:
		video_id = ''

	if video_path is None:
		video_path = '/kaggle/working/ATL AT TOR - April 19, 2015-T0MUK91ZWys.mp4'

	assert os.path.exists(video_path)

	t40 = 'kernel_29-poses%s.json' % video_id
	t4 = os.path.join('/kaggle/working', t40)
	t6 = [
		t4,
		os.path.join('/kaggle/input/garbage', t40),
	]

	t7 = [o for o in t6 if os.path.exists(o)]

	if len(t7) == 0:
		t1 = [dict(data=json.load(io.open(o, 'r')), input_path=o) for o in glob.glob('/kaggle/working/kernel_28-output%s.dir/slice-*/*.json' % video_id)]

		assert len(t1) > 0

		with io.open(t4, 'w') as f:
			f.write(json.dumps(t1))

		t7.append(t4)

	with io.open(t7[0], 'r') as f:
		t1 = json.load(f)

	t8 = sum([o['data'] for o in t1], [])
	t10 = re.compile(r'frame-(\d+)\.jpg')

	for i, o in enumerate(t8):
		o['frame_id'] = int(t10.match(o['image_id'])[1])

	t9 = sorted(t8, key=lambda o: o['frame_id'])

	t2 = pandas.DataFrame(t9)

	t5 = t2.to_xarray()
	t5['keypoints'] = xarray.DataArray(
		[numpy.array(o).reshape(17, 3) for o in t5['keypoints'].data],
		dims=['index', 'joint', 'feature'],
	)
	o_31 = kernel_31(
		image_id=t5.image_id.data,
		image_size=[kernel_32(video_path)] * t5.index.shape[0],
		keypoints=t5.keypoints.data,
	)
	for k, v in o_31['t13'].items():
		# pprint.pprint([k, v])
		t5[k] = v

	return dict(
		t5=t5,
		t2=t2,
		t9=t9,
	)


def kernel_30(
	o_29,
	ids=None,
	delay=None,
	prev_frames=None,
	max_frames=None,
	max_ids=None,
	video_path=None,
	low_portion=None,
	low_mean_conf=None,
	no_dots=None,
):
	if no_dots is None:
		no_dots = False

	if low_portion is None:
		low_portion = 0.1
	if low_mean_conf is None:
		low_mean_conf = 0.6

	if video_path is None:
		video_path = '/kaggle/working/ATL AT TOR - April 19, 2015-T0MUK91ZWys.mp4'

	if max_frames is None:
		max_frames = 9999
	if max_ids is None:
		max_ids = 70

	if prev_frames is None:
		prev_frames = 0

	t5 = o_29['t5']

	if delay is None:
		delay = 200

	if ids is None:
		numpy.random.seed(0)
		ids = numpy.random.choice(t5.index.shape[0], 10)
	elif ids == 'v1':
		t8 = numpy.where(
			numpy.logical_and(
				o_29['t5'].portion > low_portion,
				o_29['t5'].mean_conf > low_mean_conf,
			)
		)[0]
		ids = numpy.random.choice(
			t8,
			min(len(t8), 70),
			replace=False,
		)
	elif ids == 'v2':
		t8 = numpy.stack(
			[
				o_29['t5'].portion > 0.1,
				o_29['t5'].mean_conf > 0.6,
				o_29['t5']['t11'].data,
			],
			axis=0,
		).prod(axis=0)
		pprint.pprint([t8.sum(), t8.mean()])
		ids = numpy.random.choice(
			numpy.where(t8)[0],
			min(70, t8.sum()),
		)
	elif ids == 'v3':
		t8 = numpy.stack(
			[
				o_29['t5'].portion > 0.1,
				o_29['t5'].mean_conf > 0.6,
				o_29['t5']['t10'].data,
			],
			axis=0,
		).prod(axis=0)
		pprint.pprint([t8.sum(), t8.mean()])
		ids = numpy.random.choice(
			numpy.where(t8)[0],
			min(70, t8.sum()),
		)
	elif ids == 'v4':
		t8 = numpy.stack(
			[
				o_29['t5'].portion > 0.1,
				o_29['t5'].min_conf > 0.6,
				o_29['t5']['t9'].data > 0,
			],
			axis=0,
		).prod(axis=0)
		pprint.pprint([t8.sum(), t8.mean()])
		ids = numpy.random.choice(
			numpy.where(t8)[0],
			min(70, t8.sum()),
		)
	elif ids == 'v5':
		t8 = numpy.stack(
			[
				o_29['t5'].portion > 0.1,
				o_29['t5'].min_conf > 0.5,
				o_29['t5']['t8'].data > 0,
			],
			axis=0,
		).prod(axis=0)
		pprint.pprint([t8.sum(), t8.mean()])
		ids = numpy.random.choice(
			numpy.where(t8)[0],
			min(70, t8.sum()),
		)
	elif ids == 'v6':
		t8 = numpy.stack(
			[
				o_29['t5'].portion > 0.02,
				o_29['t5'].min_conf > 0.4,
				o_29['t5']['t8'].data > 0,
			],
			axis=0,
		).prod(axis=0)
		ids = numpy.random.choice(
			numpy.where(t8)[0],
			min(70, t8.sum()),
			replace=False,
		)
		pprint.pprint(
			[
				t8.sum(),
				t8.mean(),
				ids,
				o_29['t5'].sel(index=o_29['t5'].index.data[ids[:5]]).to_dict(),
			]
		)
	elif ids == 'v7':
		t8 = numpy.stack(
			[
				o_29['t5'].portion > 0.02,
				o_29['t5'].min_conf > 0.4,
				numpy.stack(
					[
						o_29['t5']['t4'].data > 0,
						o_29['t5']['t5'].data > 0,
					],
					axis=0,
				).sum(axis=0)
				> 0,
			],
			axis=0,
		).prod(axis=0)
		ids = numpy.random.choice(
			numpy.where(t8)[0],
			min(70, t8.sum()),
			replace=False,
		)
		pprint.pprint(
			[
				t8.sum(),
				t8.mean(),
				ids,
				o_29['t5'].sel(index=o_29['t5'].index.data[ids[:5]]).to_dict(),
			]
		)
	else:
		assert isinstance(ids, numpy.ndarray)

	ids = ids[:max_ids]
	pprint.pprint(['ids', ids])

	t7 = []

	t16 = video_path
	t15 = kernel_32(t16)

	for o in tqdm.tqdm(ids):
		t2 = t5.keypoints.data[o]
		t3 = t5.frame_id.data[o]

		cap = None
		try:
			cap = cv2.VideoCapture(t16)
			if prev_frames > 0:
				t14 = kernel_24(
					numpy.zeros(t15, dtype=numpy.uint8),
					t2,
				)['t3']
				t17 = (t14 == 0).astype(numpy.uint8)

				for k in range(prev_frames):
					cap.set(cv2.CAP_PROP_POS_FRAMES, t3 - prev_frames + k)
					ret, frame = cap.read()
					t12 = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
					# t13 = kernel_24(t12, t2)['t3']
					t13 = t12 * t17 + t14
					t7.append(t13)

			cap.set(cv2.CAP_PROP_POS_FRAMES, t3)
			ret, frame = cap.read()
			t4 = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
			if not no_dots:
				t6 = kernel_24(t4, t2)['t3']
			else:
				t6 = t4
			t7.append(t6)
		finally:
			if not cap is None:
				cap.release()
	kernel_25(t7[:max_frames], delay=delay)


def kernel_31(image_id, image_size, keypoints):
	def get_angle(a, b):
		from math import sqrt, acos, degrees, atan

		# print(a)
		# print(b)
		del_y = a[1] - b[1]
		del_x = b[0] - a[0]
		if del_x == 0:
			del_x = 0.1
		# print("Del_X : "+str(del_x)+"-----Del_Y: "+str(del_y))
		angle = 0

		if del_x > 0 and del_y > 0:
			angle = degrees(atan(del_y / del_x))
		elif del_x < 0 and del_y > 0:
			angle = degrees(atan(del_y / del_x)) + 180

		return angle

	def angle_gor(a, b, c, d):
		import numpy as np
		from math import sqrt, acos, degrees, atan

		ab = [a[0] - b[0], a[1] - b[1]]
		ab1 = [c[0] - d[0], c[1] - d[1]]
		cos = abs(ab[0] * ab1[0] + ab[1] * ab1[1]) / (sqrt(ab[0] ** 2 + ab[1] ** 2) * sqrt(ab1[0] ** 2 + ab1[1] ** 2) + 1e-8)
		ang = acos(cos)
		return ang * 180 / np.pi

	def sit_ang(a, b, c, d):
		ang = angle_gor(a, b, c, d)
		s1 = 0
		if not ang is None:
			# print("Angle",ang)
			if ang < 120 and ang > 40:
				s1 = 1
		return s1

	def sit_rec(a, b, c, d):
		from math import sqrt, acos, degrees, atan

		ab = [a[0] - b[0], a[1] - b[1]]
		ab1 = [c[0] - d[0], c[1] - d[1]]
		l1 = sqrt(ab[0] ** 2 + ab[1] ** 2)
		l2 = sqrt(ab1[0] ** 2 + ab1[1] ** 2)
		s = 0
		if l1 != 0 and l2 != 0:
			# print(l1,l2, "---------->>>")
			if l2 / l1 >= 1.5:
				s = 1
		return s

	t3 = []
	for i, o in enumerate(keypoints):
		t4 = numpy.min(o[:, 0])
		t5 = numpy.max(o[:, 0])
		t6 = numpy.min(o[:, 1])
		t7 = numpy.max(o[:, 1])

		t8 = (t5 - t4) * (t7 - t6)

		t9 = image_size[i]
		t10 = t9[0] * t9[1]
		t3.append(
			dict(
				t8=t8,
				t9=t9,
				t10=t10,
			)
		)
	t12 = [
		dict(
			square=t3[i]['t8'],
			total=t3[i]['t10'],
			portion=t3[i]['t8'] / (t3[i]['t10'] + 1e-8),
			keypoints=keypoints[i],
			image_name=image_id[i],
		)
		for i in range(len(t3))
	]

	for i, o in enumerate(t12):
		t1 = o['keypoints']
		t2 = get_angle(
			t1[3, :2],
			t1[4, :2],
		)
		t3 = get_angle(
			t1[6, :2],
			t1[7, :2],
		)
		t4 = 0
		if 30 < t2 and t2 < 150:
			t4 = 1
		t5 = 0
		if 30 < t3 and t3 < 150:
			t5 = 1
		t6 = t4 + t6
		t7 = 0
		if t6 == 1:
			t7 = 1
		t8 = 0
		t8 += sit_rec(
			t1[9, :2],
			t1[10, :2],
			t1[10, :2],
			t1[11, :2],
		)
		t8 += sit_rec(
			t1[12, :2],
			t1[13, :2],
			t1[13, :2],
			t1[14, :2],
		)
		t9 = 0
		t9 += sit_ang(
			t1[9, :2],
			t1[10, :2],
			t1[10, :2],
			t1[11, :2],
		)
		t9 += sit_ang(
			t1[12, :2],
			t1[13, :2],
			t1[13, :2],
			t1[14, :2],
		)
		t10 = 0
		if t8 > 0 or t9 > 0:
			t10 = 1
		t11 = 0
		if t8 == 0 and t9 == 0:
			t11 = 1
		o.update(
			dict(
				t2=t2,
				t3=t3,
				t4=t4,
				t5=t5,
				t6=t6,
				t7=t7,
				t8=t8,
				t9=t9,
				t10=t10,
				t11=t11,
				mean_conf=t1[:, 2].mean(),
				min_conf=t1[:, 2].min(),
			)
		)

	t13 = pandas.DataFrame(t12).drop(columns=['keypoints']).to_xarray()

	return dict(
		t12=t12,
		t13=t13,
	)


def kernel_32(video_path):
	assert os.path.exists(video_path)

	cap = None
	try:
		cap = cv2.VideoCapture(video_path)
		ret, frame = cap.read()
		return frame.shape
	finally:
		if not cap is None:
			cap.release()


def kernel_33():
	o_14 = kernel_14()
	o_15 = kernel_15(o_14=o_14)

	assert os.system(r""" python repo/d1/mlb_player_v5.py """) == 0
	o_17 = kernel_17(o_14=o_14, max_images=100)

	o_18 = kernel_18(o_17=o_17)
	o_19 = kernel_19(o_18=o_18)
	o_20 = kernel_20(o_18=o_18)
	o_22 = kernel_22(o_18=o_18)
	import pandas

	o_23 = kernel_23(o_18=o_18, o_22=o_22, ids=pandas.DataFrame(o_22['t4']).query('portion > 0.1').index.values)
	o_27 = kernel_27()
	o_28 = kernel_28()
	o_29 = kernel_29()
	import numpy

	o_30 = kernel_30(o_29=o_29, ids='v1')


def kernel_34(o_14):
	t1 = numpy.unique(
		o_14['o_3']['t5']['events']['event'],
		return_counts=True,
	)
	t2 = [[o, o2] for o, o2 in zip(*t1)]
	pprint.pprint(t2)


def kernel_35():
	return r"""
1. https://posetrack.net/leaderboard.php
2. https://posetrack.net/users/view_entry_details.php?entry=CF_chl2
3. https://posetrack.net/users/view_entry_details.php?entry=DCPose_chl2
4. https://github.com/Pose-Group/DCPose/blob/main/docs/Installation.md
5. https://github.com/openpifpaf/openpifpaf_posetrack
6. https://github.com/Guanghan/lighttrack
7. https://github.com/leoxiaobin/deep-high-resolution-net.pytorch
8. https://github.com/CMU-Perceptual-Computing-Lab/openpose
https://github.com/CMU-Perceptual-Computing-Lab/openpose/issues/1736#issuecomment-736846794
    """


def kernel_36():
	# -*- coding: utf-8 -*-
	"""OpenPose.ipynb

	Automatically generated by Colaboratory.

	Original file is located at
	    https://colab.research.google.com/drive/1VDjRLKAu9KLQky0gv4RLJjeH6NRPiWXy
	"""

	assert (
		os.system(r"""
        cd openpose && rm -rf build || true && mkdir build && cd build && cmake .. && make -j`nproc`
    """)
		== 0
	)

	"""# Pose Detection with OpenPose

    This notebook uses an open source project [CMU-Perceptual-Computing-Lab/openpose](https://github.com/CMU-Perceptual-Computing-Lab/openpose.git) to detect/track multi person poses on a video from your Google Drive

    @dinatih update base on https://colab.research.google.com/github/tugstugi/dl-colab-notebooks/blob/master/notebooks/OpenPose.ipynb

    ## Choose a video from your Google Drive
    """

	from google.colab import drive

	drive.mount('/content/drive')

	"""## Install OpenPose on Google Colab

    """

	# import os
	from os.path import exists, join, basename, splitext

	git_repo_url = 'https://github.com/CMU-Perceptual-Computing-Lab/openpose.git'
	project_name = splitext(basename(git_repo_url))[0]

	if 1 or not exists(project_name):
		assert os.system(r"""!rm -rf openpose""") == 0
		# see: https://github.com/CMU-Perceptual-Computing-Lab/openpose/issues/949
		print('install new CMake becaue of CUDA10')
		cmake_version = 'cmake-3.20.2-linux-x86_64.tar.gz'
		if not exists(cmake_version):
			assert os.system(r"""!wget -q 'https://cmake.org/files/v3.20/{cmake_version}' """) == 0
		assert os.system(r"""!tar xfz {cmake_version} --strip-components=1 -C /usr/local """) == 0

		print('clone openpose')
		assert os.system(r"""!git clone -q --depth 1 $git_repo_url """) == 0
		print('install system dependencies')
		assert (
			os.system(
				r"""!apt-get -qq install -y libatlas-base-dev libprotobuf-dev libleveldb-dev libsnappy-dev libhdf5-serial-dev protobuf-compiler libgflags-dev libgoogle-glog-dev liblmdb-dev opencl-headers ocl-icd-opencl-dev libviennacl-dev """
			)
			== 0
		)
		print('build openpose')
		assert os.system(r"""!cd openpose && rm -rf build || true && mkdir build && cd build && cmake .. && make -j`nproc` """) == 0

	"""## From a Google Drive's folder"""

	# import os
	# from os.path import exists, join, basename, splitext

	folder_path = '/content/drive/My Drive/openpose/'
	files = os.listdir(folder_path)
	files.reverse()
	for filename in files:
		if filename.endswith('.mp4') and not filename.endswith('-openpose.mp4'):
			print(filename)
			colab_video_path = folder_path + filename
			print(colab_video_path)
			colab_openpose_video_path = colab_video_path.replace('.mp4', '') + '-openpose.mp4'
			print(colab_openpose_video_path)
			if not exists(colab_openpose_video_path):
				assert (
					os.system(
						r"""!cd openpose && ./build/examples/openpose/openpose.bin --hand --face --number_people_max 12 --video '{colab_video_path}' --display 0 --write_video_with_audio --write_video '{colab_openpose_video_path}' # --net_resolution "-1x736" --scale_number 4 --scale_gap 0.25 """
					)
					== 0
				)

	"""## From Youtube (Downloaded to your Drive)"""

	assert os.system(r"""!pip install youtube-dl """) == 0

	youtube_id = '2021-05-07_22-00-55_UTC'
	assert os.system(r"""!youtube-dl -f mp4 -o '/content/drive/My Drive/openpose/%(id)s.mp4' {youtube_id} """) == 0
	colab_video_path = '/content/drive/My Drive/openpose/' + youtube_id + '.mp4'
	colab_openpose_video_path = colab_video_path.replace('.mp4', '') + '-openpose.mp4'

	assert (
		os.system(
			r"""!cd openpose && ./build/examples/openpose/openpose.bin --number_people_max 12 --video '{colab_video_path}' --display 0 --write_video_with_audio --write_video '{colab_openpose_video_path}' # --net_resolution "-1x736" --scale_number 4 --scale_gap 0.25 """
		)
		== 0
	)

	"""## Run OpenPose"""

	assert (
		os.system(
			r"""!wget 'https://cdn-eu-hz-4.ufile.io/get/z5yes0he?token=ZWUyZjMyNDBmNTRlMWY0NjRkZTUzYzQzNjg2OWY4ODgzMzA1ODFjNzY0YzYxYWFjNzM1ZTU2OWYwNzQyNzVkOWUwYjY3MjdiZmI1MDg0NmIyMzA3ODhiZmQ2YmI3ZWYyOTE3NDBlNDEwY2JlZTc5N2MwMmIxYjYzZGJjYTZjYzl3K3dtK25xdXE2M1ZUZXZMUU5CYzI0WjBtUEk4OTJQYzFvaTJXa1huRkdtNlhjZGxlTHkvTEJVNVlucnBOZFdHMXBiVkszeHBKWEFaTzRKK1h4Zy9BRDNvbkttNDhJVXRKZjJuSUIyTDVaR0UydjM3amtVdE93aFQ4ZXFGTlZYeVZiTXQwT3pkOEdLTklQRUhZNmR1MHRPeVdMb3ZHRWV3R3BYWStQcElkeUdDTkVvUU1IRTUxaE1acDlCM3htRDBaS2ZjWEpLMXlpNXRWUWdLWEoreld3N3VvLy9ocXE2RUxPS2pDdENtVjB0Zi9qWGh3WEIwK3RzU0xZekloK3k2' -O output.mp4 """
		)
		== 0
	)

	# video_folder = os.path.dirname(colab_video_path)
	# video_base_name = os.path.basename(colab_video_path)
	# print(video_base_name)
	# import os
	# from os.path import exists, join, basename, splitext
	# colab_video_path = '/content/drive/My Drive/bachata.mp4'
	colab_video_path = '/content/output.mp4'
	colab_openpose_video_path = colab_video_path.replace('.mp4', '') + '-openpose.mp4'

	assert (
		os.system(
			r"""!cd openpose && ./build/examples/openpose/openpose.bin --number_people_max 12 --video '{colab_video_path}' --display 0 --write_video_with_audio --write_video '{colab_openpose_video_path}' # --net_resolution "-1x736" --scale_number 4 --scale_gap 0.25 """
		)
		== 0
	)

	assert os.system(r"""!cmake -version """) == 0


def kernel_37():
	return r"""
1. https://www.youtube.com/channel/UCcTy8yBARva3WzrmIcaaWPA/about
2. https://www.play-cricket.com/website/results/4721802
    """


def kernel_38(
	video_path,
	framerate=None,
	max_seconds=None,
	ids=None,
	prev_frames=None,
	delay=None,
	low_mean_conf=None,
	low_portion=None,
	no_dots=None,
):
	if ids is None:
		ids = 'v7'

	if prev_frames is None:
		prev_frames = 59

	if delay is None:
		delay = 3

	t2 = hashlib.sha256(video_path.encode('utf-8')).hexdigest()

	t1 = '/kaggle/working/video%s.mp4' % t2

	if not os.path.exists(t1):
		subprocess.check_call(
			[
				'youtube-dl',
				'-f',
				'18',
				video_path,
				'-o',
				t1,
			]
		)

	kernel_28(
		t1,
		framerate=framerate,
		max_seconds=max_seconds,
		video_id=t2,
	)

	o_29 = kernel_29(
		t1,
		video_id=t2,
	)

	o_30 = kernel_30(
		o_29=o_29,
		ids=ids,
		delay=delay,
		prev_frames=prev_frames,
		max_frames=9999,
		max_ids=999,
		video_path=t1,
		low_mean_conf=low_mean_conf,
		low_portion=low_portion,
		no_dots=no_dots,
	)

	return dict(
		o_29=o_29,
		o_30=o_30,
	)
