조수연 / Find_your_own_personal_color

Go to a project
Toggle navigation Toggle navigation pinning
starbucksdolcelatte
86ec6089 1 parent 83570f8d

delete legacy code

Expand all
Inline Side-by-side
Showing 397 changed files with 0 additions and 957 deletions
{
"cells": [],
"metadata": {},
"nbformat": 4,
"nbformat_minor": 2
}
This diff is collapsed. Click to expand it.
No preview for this file type
No preview for this file type
from colormath.color_objects import LabColor, sRGBColor
from colormath.color_conversions import convert_color
#sRGB 클래스 인스턴스 생성. RGB 값을 넣을 때 is_upscaled=True로 해줘야 함
rgb = sRGBColor(222.5, 201.4, 188.9, is_upscaled=True)
print(rgb)
#lab로 변환. through_rgb_type=sRGBColor 로 넣어준다.(AdobeRGBColor클래스 사용 X)
lab = convert_color(rgb, LabColor, through_rgb_type=sRGBColor)
print(type(lab.lab_l))
import cv2
from detect_face import DetectFace
from dominant_colors import DominantColors
from tone_analysis import ToneAnalysis
from getjson import GetJson
import imutils
from colormath.color_objects import LabColor, sRGBColor
from colormath.color_conversions import convert_color
from itertools import compress
predictor = 'shape_predictor_68_face_landmarks.dat'
getJson = GetJson()
C = getJson.get_standard('res/standard.json')
# [spring[skin, eyebrow, eye, mouth], summer[skin, eyebrow, eye, mouth],
# fall[skin, eyebrow, eye, mouth], winter[skin, eyebrow, eye, mouth]]
LLL = [[[],[],[],[]] for _ in range(4)]
aaa = [[[],[],[],[]] for _ in range(4)]
bbb = [[[],[],[],[]] for _ in range(4)]
RR = [[[],[],[],[]] for _ in range(4)]
GG = [[[],[],[],[]] for _ in range(4)]
BB = [[[],[],[],[]] for _ in range(4)]
seasons = ['spring', 'summer', 'fall', 'winter']
for j in range(4):
path = "res/tc/" + seasons[j] + "/"
for i in range(25):
img = path + str(i+1) + '.jpg'
print(img)
df = DetectFace(predictor, img)
# Try: Extract mouth part
mouth = df.extract_face_part(df.mouth)
# Try: Extract left eye part
l_eye = df.extract_face_part(df.left_eye)
# Try: Extract left eyebrow part
l_eyebrow = df.extract_face_part(df.left_eyebrow)
# Try : Extract cheek part
l_cheek = df.cheek_img[0]
# Create an DominantColors instance on left cheek image
clusters = 5
lc_dc = DominantColors(l_cheek, clusters)
lc_dc.dominantColors()
lc_colors = lc_dc.plotHistogram()
le_dc = DominantColors(l_eye, clusters)
le_dc.dominantColors()
le_colors = le_dc.plotHistogram()
leb_dc = DominantColors(l_eyebrow, clusters)
leb_dc.dominantColors()
leb_colors = leb_dc.plotHistogram()
m_dc = DominantColors(mouth, clusters)
m_dc.dominantColors()
m_colors = m_dc.plotHistogram()
cy_rgb = [lc_colors[0:3], leb_colors[0:3], le_colors[0:3], m_colors[0:3]]
cy_lab = []
for iii in range(3):
for sth in range(4):
color = cy_rgb[sth][iii]
RR[j][sth].append(color[0])
GG[j][sth].append(color[1])
BB[j][sth].append(color[2])
rgb = sRGBColor(color[0], color[1], color[2], is_upscaled=True)
lab = convert_color(rgb, LabColor, through_rgb_type=sRGBColor)
cy_lab.append([format(lab.lab_l,".2f"), format(lab.lab_a,".2f"), format(lab.lab_b,".2f")])
LLL[j][sth].append(format(lab.lab_l,".2f"))
aaa[j][sth].append(format(lab.lab_a,".2f"))
bbb[j][sth].append(format(lab.lab_b,".2f"))
sth += 1
bodys = ['left cheek', 'left eyebrow', 'left eye', 'mouth']
print(seasons[j])
for ii in range(4):
print(bodys[ii])
print("L : ", LLL[j][ii])
print("a : ", aaa[j][ii])
print("b : ", bbb[j][ii])
print("R : ", RR[j][ii])
print("G : ", GG[j][ii])
print("B : ", BB[j][ii])
plotRGB = [[[RR[j][ii][iii], GG[j][ii][iii], BB[j][ii][iii]] for iii in range(75)]
for ii in range(4)] # ii is cheek, eyebr, eye, mouth
print("**************")
print(plotRGB[0])
print(plotRGB[1])
print(plotRGB[2])
print(plotRGB[3])
'''
tone_analysis = ToneAnalysis()
print("******************")
a = [400, 200, 20] # 가중치
spring = 0
summer = 1
fall = 2
winter = 3
result_prob = []
for season in range(4):
result_prob.append(format(tone_analysis.probability(cy_rgb, season, C, a),".2f"))
print("결과")
print("봄 : ", result_prob[spring], "%")
print("여름 : ", result_prob[summer], "%")
print("가을 : ", result_prob[fall], "%")
print("겨울 : ", result_prob[winter], "%")
print("******************")
'''
'''
closer_to_warm = 28 - cy_lab[0][2]
print("distance to warm : ", closer_to_warm)
closer_to_cool = cy_lab[0][2] - 19
print("distance to cool : ", closer_to_cool)
if(closer_to_warm < closer_to_cool):
if(result_prob[spring] >= result_prob[fall]):
print("봄 웜톤")
else:
print("가을 웜톤")
else:
if(result_prob[summer] >= result_prob[winter]):
print("여름 쿨톤")
else:
print("겨울 쿨톤")
'''
This diff is collapsed. Click to expand it.
# coding: utf-8
# import the necessary packages
from imutils import face_utils
import numpy as np
import imutils
import dlib
import cv2
import matplotlib.pyplot as plt
class DetectFace:
def __init__(self, shape_predictor_dat, image):
# initialize dlib's face detector (HOG-based)
# and then create the facial landmark predictor
self.detector = dlib.get_frontal_face_detector()
self.predictor = dlib.shape_predictor(shape_predictor_dat)
#face detection part
img = cv2.imread(image)
self.img = imutils.resize(img, width = 500)
self.gray = cv2.cvtColor(self.img, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale image
self.rects = self.detector(self.gray, 1)
# init face parts
self.mouth = []
self.right_eyebrow = []
self.left_eyebrow = []
self.right_eye = []
self.left_eye = []
self.nose = []
self.jaw = []
self.cheek_img = [[],[]] # index 0 : left, 1 : right
# detect the face parts and set the variables
self.detect_face_part() # mouth, right_eyebrow, ..., jaw : np.array
self.cheek_img = self.detect_cheek() # image
# return type : np.array
def detect_face_part(self):
# loop over the face detections
# i : name
# 0 : mouth, 1 : right_eyebrow, 2 : left_eyebrow
# 3 : right_eye, 4 : left_eye, 5 : nose, 6 : jaw
face_parts = [[],[],[],[],[],[],[]]
for (i, rect) in enumerate(self.rects):
# determine the facial landmarks for the face region, then
# convert the landmark (x, y)-coordinates to a NumPy array
shape = self.predictor(self.gray, rect)
shape = face_utils.shape_to_np(shape)
idx = 0
# loop over the face parts individually
for (name, (i, j)) in face_utils.FACIAL_LANDMARKS_IDXS.items():
# clone the original image so we can draw on it, then
# display the name of the face part on the image
clone = self.img.copy()
cv2.putText(clone, name, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
# loop over the subset of facial landmarks, drawing the
# specific face part
for (x, y) in shape[i:j]:
cv2.circle(clone, (x, y), 1, (0, 0, 255), -1)
#print(name)
#print(shape[i:j])
face_parts[idx] = shape[i:j]
idx += 1
# extract the ROI of the face region as a separate image
(x, y, w, h) = cv2.boundingRect(np.array([shape[i:j]]))
roi = self.img[y:y + h, x:x + w]
roi = imutils.resize(roi, width=250, inter=cv2.INTER_CUBIC)
'''
# show the particular face part
cv2.imshow("ROI", roi)
cv2.imshow("Image", clone)
cv2.waitKey(0)
'''
# visualize all facial landmarks with a transparent overlay
output = face_utils.visualize_facial_landmarks(self.img, shape)
#cv2.imshow("Image", output)
#cv2.waitKey(0)
# set the variables
# Caution: this coordinates fits on the RESIZED image.
self.mouth = face_parts[0]
self.right_eyebrow = face_parts[1]
self.left_eyebrow = face_parts[2]
self.right_eye = face_parts[3]
self.left_eye = face_parts[4]
self.nose = face_parts[5]
self.jaw = face_parts[6]
# parameter example : self.right_eye
# return type : image
def extract_face_part(self, part):
pts = part
# Create an mask
mask = np.zeros((self.img.shape[0], self.img.shape[1]))
cv2.fillConvexPoly(mask, pts, 1)
mask = mask.astype(np.bool)
#print(mask)
# Mask For background
inversed_mask = np.logical_not(mask)
#print(inversed_mask)
# Create a blank black image
blue = np.zeros_like(self.img)
# Fill image with blue color(set each pixel to blue)
blue[:] = [255, 0, 0]
# extract background by applying inversed_mask
# extract right eye by applying polygon mask
out2 = np.zeros_like(self.img)
out2[inversed_mask] = blue[inversed_mask]
#cv2.imshow("out2", out2)
#cv2.waitKey(0)
# extract right eye by applying polygon mask
out = np.zeros_like(self.img)
out[mask] = self.img[mask]
#out = out[mask] + blue
#cv2.imshow("out", out)
#cv2.waitKey(0)
# crop the image
(x, y, w, h) = cv2.boundingRect(pts)
crop1 = out[y:y + h, x:x + w]
crop2 = out2[y:y + h, x:x + w]
crop = cv2.add(crop1,crop2)
#cv2.imshow("Image2", crop)
#cv2.waitKey(0)
return crop
# return type = image
def detect_cheek(self):
cheek = [[],[]]
# rect is the face detected
shape = self.predictor(self.gray, self.rects[0])
shape = face_utils.shape_to_np(shape)
# Cheeks are detected by relative position to the face landmarks
left = self.img[shape[29][1]:shape[33][1], shape[4][0]:shape[48][0]] #left cheek
right = self.img[shape[29][1]:shape[33][1], shape[54][0]:shape[12][0]] #right cheek
cheek[0] = left
cheek[1] = right
# show the particular face part
#cv2.imshow("left", left)
#cv2.imshow("right", right)
#cv2.waitKey(0)
return cheek
import cv2
import numpy as np
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from skimage import io
from itertools import compress
class DominantColors:
CLUSTERS = None
IMAGE = None
COLORS = None
LABELS = None
def __init__(self, image, clusters=3):
self.CLUSTERS = clusters
self.IMAGE = image
def dominantColors(self):
#read image
#img = cv2.imread(self.IMAGE)
img = self.IMAGE
#convert to rgb from bgr
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
#reshaping to a list of pixels
img = img.reshape((img.shape[0] * img.shape[1], 3))
#save image after operations
self.IMAGE = img
#using k-means to cluster pixels
kmeans = KMeans(n_clusters = self.CLUSTERS)
kmeans.fit(img)
#the cluster centers are our dominant colors.
self.COLORS = kmeans.cluster_centers_
#save labels
self.LABELS = kmeans.labels_
#returning after converting to integer from float
return self.COLORS.astype(int)
def rgb_to_hex(self, rgb):
return '#%02x%02x%02x' % (int(rgb[0]), int(rgb[1]), int(rgb[2]))
def plotClusters(self):
#plotting
fig = plt.figure()
ax = Axes3D(fig)
for label, pix in zip(self.LABELS, self.IMAGE):
ax.scatter(pix[0], pix[1], pix[2], color = self.rgb_to_hex(self.COLORS[label]))
plt.show()
def plotHistogram(self):
#labels form 0 to no. of clusters
numLabels = np.arange(0, self.CLUSTERS+1)
#create frequency count tables
(hist, _) = np.histogram(self.LABELS, bins = numLabels)
hist = hist.astype("float")
hist /= hist.sum()
#appending frequencies to cluster centers
colors = self.COLORS
#descending order sorting as per frequency count
colors = colors[(-hist).argsort()]
hist = hist[(-hist).argsort()]
#creating empty chart
chart = np.zeros((50, 500, 3), np.uint8)
start = 0
for i in range(self.CLUSTERS):
colors[i][0] = int(colors[i][0])
colors[i][1] = int(colors[i][1])
colors[i][2] = int(colors[i][2])
# Blue mask 제거
fil = [colors[i][2] < 250 and colors[i][0] > 10 for i in range(self.CLUSTERS)]
colors = list(compress(colors, fil))
#creating color rectangles
for i in range(len(colors)):
end = start + hist[i] * 500
#getting rgb values
r = colors[i][0]
g = colors[i][1]
b = colors[i][2]
#print(r,g,b)
#using cv2.rectangle to plot colors
cv2.rectangle(chart, (int(start), 0), (int(end), 50), (r,g,b), -1)
start = end
#display chart
plt.figure()
plt.axis("off")
plt.imshow(chart)
plt.show()
return colors
import pandas as pd
class ListFromExcel:
df = None
skin = None
pupil = None
hair = None
def __init__(self, path):
self.df = pd.read_excel(path, sheet_name='original')
self.skin = pd.concat([self.df[1:5],self.df[9:13]]).values.tolist()
self.pupil = pd.concat([self.df[19:21],self.df[25:27]]).values.tolist()
self.hair = pd.concat([self.df[31:33],self.df[37:39]]).values.tolist()
'''
코드에서 [1:5],[9:13]이 skin 이며 [:][0:3]이 spring의 rgb라는 등의 상수는
철저히 res/tone_color_standard.xlsx 파일 기준으로 작성된 것이며
다른 엑셀 문서에 대해서는 아래 함수가 작동하지 않을 수 있다.
만약 엑셀에 새로운 기준값을 추가하는 등의 변동사항이 생기면
이 코드 상의 상수도 적절히 변경해주어야 한다.
이 파이썬 코드는
엑셀에 정리된 색상 기준 값을 list로 변환하기 위해 작성되었으며
리스트는 아래와 같이 이루어져있다.
[standard_1[spr[r,g,b], smr[r,g,b], fal[r,g,b], wnt[r,g,b]],
standard_2[spr[r,g,b], smr[r,g,b], fal[r,g,b], wnt[r,g,b]],
standard_3[spr[r,g,b], smr[r,g,b], fal[r,g,b], wnt[r,g,b]],
...
standard_n[spr[r,g,b], smr[r,g,b], fal[r,g,b], wnt[r,g,b]]]
여기서 r,g,b 대신 [v,c]가 들어갈 수도, [l,a,b]가 들어갈 수도 있다.
'''
# RGB values
def get_rgb(self, list):
ret_list=[]
for i in range(len(list)):
ret_list.append([list[i][0:3], list[i][9:12],
list[i][18:21], list[i][27:30]])
return ret_list
# VC values from HVC color space
def get_vc(self, list):
ret_list=[]
for i in range(len(list)):
ret_list.append([list[i][3:5], list[i][12:14],
list[i][21:23], list[i][30:32]])
return ret_list
# Lab values
def get_lab(self, list):
ret_list=[]
for i in range(len(list)):
ret_list.append([list[i][5:8], list[i][14:17],
list[i][23:26], list[i][32:35]])
return ret_list
def convert_list(self, skin_list, hair_list, eye_list):
'''
skin[standard_1[spr[r,g,b], smr[r,g,b], fal[r,g,b], wnt[r,g,b]],
standard_2[spr[r,g,b], smr[r,g,b], fal[r,g,b], wnt[r,g,b]],
...
standard_n[spr[r,g,b], smr[r,g,b], fal[r,g,b], wnt[r,g,b]]],
hair[], eye[]
를 아래와 같이 변환
spr[standard_1[skin[R,G,B], hair[R,G,B], eye[R,G,B]],
...
standard_n[skin[R,G,B], hair[R,G,B], eye[R,G,B]]],
smr[standard_1[skin[R,G,B], hair[R,G,B], eye[R,G,B]],
...
standard_n[skin[R,G,B], hair[R,G,B], eye[R,G,B]]],
...
wnt[standard_1[skin[R,G,B], hair[R,G,B], eye[R,G,B]],
...
standard_n[skin[R,G,B], hair[R,G,B], eye[R,G,B]]]]
주의: 매개변수 skin_list, hair_list, eye_list 길이 같아야 함
'''
ret = []
temp = []
for s in range(4): #season
for i in range(len(skin_list)): #standard
temp.append([skin_list[i][s], hair_list[i][s], eye_list[i][s]])
ret.append(temp)
temp = []
return ret
import json
from collections import OrderedDict
class GetJson:
def get_standard(self, filename):
with open(filename, mode='r') as f:
json_data = json.load(f, object_pairs_hook=OrderedDict)
# 아래와 같은 계절별 기준값이 들어갈 리스트
result_list = [[[],[],[],[]],[[],[],[],[]],[[],[],[],[]],[[],[],[],[]]]
'''
spr[standard_1[skin[R,G,B], hair[R,G,B], eye[R,G,B]],
...
standard_n[skin[R,G,B], hair[R,G,B], eye[R,G,B]]],
smr[standard_1[skin[R,G,B], hair[R,G,B], eye[R,G,B]],
...
standard_n[skin[R,G,B], hair[R,G,B], eye[R,G,B]]],
...
wnt[standard_1[skin[R,G,B], hair[R,G,B], eye[R,G,B]],
...
standard_n[skin[R,G,B], hair[R,G,B], eye[R,G,B]]]]
'''
# iterate over each dictionary in our list
i = 0
j = 0
for season in json_data:
for std in json_data[season]:
for body_part in json_data[season][std]:
result_list[i][j].append(json_data[season][std][body_part])
j += 1
i += 1
j = 0
return result_list
import json
def get_standard(filename):
with open(filename, mode='r') as f:
json_data = json.load(f)
# 아래와 같은 계절별 기준값이 들어갈 리스트
result_list = [[[],[]],[[],[]],[[],[]],[[],[]]]
'''
spr[standard_1[skin[R,G,B], hair[R,G,B], eye[R,G,B]],
...
standard_n[skin[R,G,B], hair[R,G,B], eye[R,G,B]]],
smr[standard_1[skin[R,G,B], hair[R,G,B], eye[R,G,B]],
...
standard_n[skin[R,G,B], hair[R,G,B], eye[R,G,B]]],
...
wnt[standard_1[skin[R,G,B], hair[R,G,B], eye[R,G,B]],
...
standard_n[skin[R,G,B], hair[R,G,B], eye[R,G,B]]]]
'''
# iterate over each dictionary in our list
i = 0
j = 0
for season in json_data:
for std in json_data[season]:
for body_part in json_data[season][std]:
result_list[i][j].append(json_data[season][std][body_part])
j += 1
i += 1
j = 0
print(result_list) # ['Hurzuf', 'Novinki']
get_standard('standard.json')
import cv2
from detect_face import DetectFace
from dominant_colors import DominantColors
from tone_analysis import ToneAnalysis
from getjson import GetJson
import imutils
from colormath.color_objects import LabColor, sRGBColor
from colormath.color_conversions import convert_color
# 이성경(res/lees.jpg) dominant colors by order of histogram
# skin, hair, eye 순서
lsk_rgb = [[222.5, 201.4, 188.9], [138.6, 98.4, 55.0], [159.8, 115.8, 61.7]]
lsk_lab = []
for color in lsk_rgb:
rgb = sRGBColor(color[0], color[1], color[2], is_upscaled=True)
lab = convert_color(rgb, LabColor, through_rgb_type=sRGBColor)
lsk_lab.append([lab.lab_l, lab.lab_a, lab.lab_b])
# 봄웜1(res/spring_1_0.png) dominant colors by order of histogram
# skin, hair, eye 순서
sw1_rgb = [[201.58, 158.42, 142.44], [47.38, 37.76, 35.96], [44.92, 39.05, 41.00]]
sw1_lab = []
for color in sw1_rgb:
rgb = sRGBColor(color[0], color[1], color[2], is_upscaled=True)
lab = convert_color(rgb, LabColor, through_rgb_type=sRGBColor)
sw1_lab.append([lab.lab_l, lab.lab_a, lab.lab_b])
# 채연(res/chaeyeon.jpg) dominant colors by order of histogram
# skin, hair, eye 순서
cy_rgb = [[239.74, 211.85, 196.76], [16.02, 23.75, 39.83], [51.38, 35.24, 40.31]]
cy_lab = []
for color in cy_rgb:
rgb = sRGBColor(color[0], color[1], color[2], is_upscaled=True)
lab = convert_color(rgb, LabColor, through_rgb_type=sRGBColor)
cy_lab.append([lab.lab_l, lab.lab_a, lab.lab_b])
getJson = GetJson()
C = getJson.get_standard('res/standard.json')
tone_analysis = ToneAnalysis()
print("******************")
a = [400, 300, 10] # 가중치
spring = 0
summer = 1
fall = 2
winter = 3
result_prob = []
for season in range(4):
result_prob.append(format(tone_analysis.probability(cy_rgb, season, C, a),".2f"))
print("결과")
print("봄 : ", result_prob[spring], "%")
print("여름 : ", result_prob[summer], "%")
print("가을 : ", result_prob[fall], "%")
print("겨울 : ", result_prob[winter], "%")
print("******************")
if(tone_analysis.is_warm(cy_rgb)):
if(result_prob[spring] >= result_prob[fall]):
print("봄 웜톤")
else:
print("가을 웜톤")
else:
if(result_prob[summer] >= result_prob[winter]):
print("여름 쿨톤")
else:
print("겨울 웜톤")
'''
# Set paths
image = "res/chaeyeon.jpg"
predictor = "shape_predictor_68_face_landmarks.dat"
# Create an DetectFace instance
df = DetectFace(predictor, image)
# Try: Extract mouth part
mouth = df.extract_face_part(df.mouth)
# Try: Extract right eye part
r_eye = df.extract_face_part(df.right_eye)
# Try: Extract left eye part
l_eye = df.extract_face_part(df.left_eye)
# Try : Extract cheek part
l_cheek = df.cheek_img[0]
r_cheek = df.cheek_img[1]
# Create an DominantColors instance on left cheek image
clusters = 5
lc_dc = DominantColors(l_cheek, clusters)
lc_colors = lc_dc.dominantColors()
print("left cheek")
lc_dc.plotHistogram()
# Create an DominantColors instance on left cheek image
rc_dc = DominantColors(r_cheek, clusters)
rc_colors = rc_dc.dominantColors()
print("right cheek")
rc_dc.plotHistogram()
# Try : Dominant color on left_eye
clusters = 6
dc_le = DominantColors(l_eye, clusters)
colors = dc_le.dominantColors()
print("left eye")
dc_le.plotHistogram()
# Try : Dominant color on right_eye
dc_re = DominantColors(r_eye, clusters)
colors = dc_re.dominantColors()
print("right eye")
dc_re.plotHistogram()
# hair
hair_img = "res/chaeyeon_hair.jpg"
img = cv2.imread(hair_img)
resized_img = imutils.resize(img, width = 100)
clusters = 6
dc_hair = DominantColors(resized_img, clusters)
colors = dc_hair.dominantColors()
print("hair")
dc_hair.plotHistogram()
skin = DominantColors(df.cheek_img[0], clusters = 5)
skin_colors = list(skin.dominantColors()[0])
hair = DominantColors(resized_img, clusters = 6)
hair_colors = list(hair.dominantColors()[0])
eye = DominantColors(l_eye, clusters = 6)
eye_colors = list(eye.dominantColors()[0])
#skin_colors2 = list(skin.plotHistogram())
print("종윤님코드")
print(skin_colors)
print(hair_colors)
print(eye_colors)
print(" ")
print("descending order")
#print(skin_colors2)
print(" ")
'''
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
def plotStd(arr):
season_label = ['spring', 'summer', 'fall', 'winter']
season_color = ['green', 'blue', 'red', 'gray']
fig = plt.figure()
ax = Axes3D(fig)
for seasons in arr:
i = 0
for s in seasons:
ax.scatter(s[0], s[1], s[2], label = season_label[i], color = season_color[i])
i += 1
ax.set_xlabel('L value')
ax.set_ylabel('a value')
ax.set_zlabel('b value')
# plt.xlabel('L value')
# plt.ylabel('a value')
# plt.zlabel('b value')
plt.show()
#[봄여름가을겨울]*5개의 기준
skin_lab = [[[87.39, -2.2, 16.21],
[84.48, 0.75, 14.23],
[80.58, -0.1, 25.46],
[91.47, -0.7, 9.96]],
[[84.57, -0.21, 28.38],
[84.81, 6.59, 19.93],
[73.88, 2.55, 20.96],
[89.53, 0.74, 12.14]],
[[79.84, 11.02, 33.65],
[83.7, 5.53, 17.71],
[75.69, 4.55, 27.02],
[81.76, 14.12, 29.2]],
[[81.8, 6, 34.05],
[82.88, 10.99, 26.24],
[72.75, 3.2, 38.52],
[73.82, 8.42, 27.3]],
[[83.4, 3.6575, 28.0725],
[83.9675, 5.965, 19.5275],
[75.725, 2.5575, 27.99],
[84.145, 5.6375, 19.65]]]
plotStd(skin_lab)
This diff is collapsed. Click to expand it.
봄
0 공실이
1 리즈리사
2 선아
3 세진
4 윤터터
5 하늘
여름
0 도형
1 연우
2 예스리안
3 쿠키
4 한별
5 햄튜브
가을
0 제나
1 경선
2 조효진
3 지환
겨울
0 김습습
1 도나
2 아붐
3 원딘
{
"spring": {
"std1":{
"skin":[85.77, 4.46, 32.97],
"hair":[55.15, 10.24, 53.42],
"eye":[55.29, 7.45, 54.94]},
"std2":{
"skin":[83.49, 9.17, 40.32],
"hair":[29.66, 28.28, 37.98],
"eye":[41.1, 21.79, 50.5]},
"std3":{
"skin":[82.19, 12.5, 32],
"hair":[55.15, 10.24, 53.42],
"eye":[55.29, 7.45, 54.94]},
"std4":{
"skin":[83.4, 4.92, 50.15],
"hair":[29.66, 28.28, 37.98],
"eye":[41.1, 21.79, 50.5]}
},
"summer":{
"std1":{
"skin":[91.46, -5.31, 37.43],
"hair":[28.17, 1.7, 32.61],
"eye":[32.81, 3.62, 33.16]},
"std2":{
"skin":[88.78, 4.7, 23.99],
"hair":[44.8, 5.73, 52.9],
"eye":[44.74, 3.77, 50.4]},
"std3":{
"skin":[87.7, 2.55, 34.55],
"hair":[55.15, 10.24, 53.42],
"eye":[55.29, 7.45, 54.94]},
"std4":{
"skin":[85.11, 1.71, 56.31],
"hair":[29.66, 28.28, 37.98],
"eye":[41.1, 21.79, 50.5]}
},
"fall":{
"std1":{
"skin":[88.54, -1.55, 46.33],
"hair":[51.08, 11.21, 53.26],
"eye":[46.83, 8.29, 55.25]},
"std2":{
"skin":[83.74, 3.79, 38.88],
"hair":[42.78, 3.01, 51.59],
"eye":[38.69, 8.07, 48.49]},
"std3":{
"skin":[82.26, 5.15, 49.69],
"hair":[55.15, 10.24, 53.42],
"eye":[55.29, 7.45, 54.94]},
"std4":{
"skin":[69.25, 5.07, 46.8],
"hair":[29.66, 28.28, 37.98],
"eye":[41.1, 21.79, 50.5]}
},
"winter": {
"std1":{
"skin":[88.22, -1.29, 47.49],
"hair":[49.45, 8.27, 54.2],
"eye":[46, 10.11, 54.8]},
"std2":{
"skin":[83.16, 1.24, 40.16],
"hair":[43.26, 8.3, 52.41],
"eye":[40.38, 5.91, 49.44]},
"std3":{
"skin":[83.56, 0.25, 54.77],
"hair":[55.15, 10.24, 53.42],
"eye":[55.29, 7.45, 54.94]},
"std4":{
"skin":[70.8, 4.61, 48.24],
"hair":[29.66, 28.28, 37.98],
"eye":[41.1, 21.79, 50.5]}
}
}
{
"spring": {
"std1":{
"skin":[16.21, 0.172, 0],
"hair":[42.48, 0.799, 0],
"eye":[35.09, 0.575, 0]},
"std2":{
"skin":[28.38, 0.316, 0],
"hair":[23.93, 0.608, 0],
"eye":[21.53, 0.479, 0]},
"std3":{
"skin":[33.65, 0.431, 0],
"hair":[42.48, 0.799, 0],
"eye":[35.09, 0.575, 0]},
"std4":{
"skin":[34.05, 0.408, 0],
"hair":[23.93, 0.608, 0],
"eye":[21.53, 0.479, 0]}
},
"summer":{
"std1":{
"skin":[14.23, 0.175, 0],
"hair":[4.9, 0.200, 0],
"eye":[16.17, 0.354, 0]},
"std2":{
"skin":[19.93, 0.268, 0],
"hair":[8.18, 0.253, 0],
"eye":[8.61, 0.341, 0]},
"std3":{
"skin":[17.71, 0.243, 0],
"hair":[4.9, 0.200, 0],
"eye":[16.17, 0.354, 0]},
"std4":{
"skin":[26.24, 0.353, 0],
"hair":[8.18, 0.253, 0],
"eye":[8.61, 0.341, 0]}
},
"fall":{
"std1":{
"skin":[25.46, 0.300, 0],
"hair":[21.11, 0.546, 0],
"eye":[17.72, 0.448, 0]},
"std2":{
"skin":[20.96, 0.286, 0],
"hair":[17.72, 0.448, 0],
"eye":[17.41, 0.516, 0]},
"std3":{
"skin":[27.02, 0.355, 0],
"hair":[21.11, 0.546, 0],
"eye":[17.72, 0.448, 0]},
"std4":{
"skin":[38.52, 0.480, 0],
"hair":[17.72, 0.448, 0],
"eye":[17.41, 0.516, 0]}
},
"winter": {
"std1":{
"skin":[9.96, 0.109, 0],
"hair":[3.79, 0.283, 0],
"eye":[9.82, 0.363, 0]},
"std2":{
"skin":[12.14, 0.145, 0],
"hair":[12.24, 0.387, 0],
"eye":[4.1, 0.177, 0]},
"std3":{
"skin":[29.2, 0.396, 0],
"hair":[3.79, 0.283, 0],
"eye":[9.82, 0.363, 0]},
"std4":{
"skin":[27.3, 0.383, 0],
"hair":[12.24, 0.387, 0],
"eye":[4.1, 0.177, 0]}
}
}
This file is too large to display.
This file is too large to display.
No preview for this file type
No preview for this file type
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.