HebEMO_demo / pyplutchik.py
avichr's picture
Create pyplutchik.py
ee0a609
raw
history blame contribute delete
No virus
43.9 kB
"""
**********
Plutchik
**********
This package contains a data visualization tool for corpora annotated with emotions.
Given a JSON representation of the Plutchik's emotions (or dyads) in a text or in a group of texts,
it draws the corresponding Plutchik's flower.
See Plutchik, Robert. "A general psychoevolutionary theory of emotion." Theories of emotion. Academic press, 1980. 3-33.
--------
repository available at https://www.github.com/alfonsosemeraro/pyplutchik
@author: Alfonso Semeraro <alfonso.semeraro@gmail.com>
"""
import shapely.geometry as sg
import matplotlib.pyplot as plt
import descartes
from math import sqrt, cos, sin, radians
import numpy as np
from matplotlib import colors
__author__ = """Alfonso Semeraro (alfonso.semeraro@gmail.com)"""
__all__ = ['emo_params',
'dyad_params',
'_rotate_point',
'_polar_coordinates',
'_neutral_central_circle',
'_petal_shape_emotion',
'_petal_shape_dyad',
'_petal_spine_emotion',
'_petal_spine_dyad',
'_petal_circle',
'_draw_emotion_petal',
'_draw_dyad_petal',
'_check_scores_kind',
'plutchik']
def emo_params(emotion):
"""
Gets color and angle for drawing a petal.
Color and angle depend on the emotion name.
Required arguments:
----------
*emotion*:
Emotion's name. Possible values:
['joy', 'trust', 'fear', 'surprise', 'sadness', 'disgust', 'anger', 'anticipation']
Returns:
----------
*color*:
Matplotlib color for the petal. See: https://matplotlib.org/3.1.0/gallery/color/named_colors.html
*angle*:
Each subsequent petal is rotated 45° around the origin.
Notes:
-----
This function allows also 8 principal emotions, one for each Plutchik's flower petal.
No high or low intensity emotions are allowed (no 'ecstasy' or 'serenity', for instance).
"""
if emotion == 'joy':
color = 'gold'
angle = 0
elif emotion == 'trust':
color = 'olivedrab'
angle = -45
elif emotion == 'fear':
color = 'forestgreen'
angle = -90
elif emotion == 'surprise':
color = 'skyblue'
angle = -135
elif emotion == 'sadness':
color = 'dodgerblue'
angle = -180
elif emotion == 'disgust':
color = 'slateblue'
angle = -225
elif emotion == 'anger':
color = 'orangered'
angle = -270
elif emotion == 'anticipation':
color = 'darkorange'
angle = -315
else:
raise Exception("""Bad input: {} is not an accepted emotion.
Must be one of 'joy', 'trust', 'fear', 'surprise', 'sadness', 'disgust', 'anger', 'anticipation'""".format(emotion))
return color, angle, 0
def dyad_params(dyad):
"""
Gets colormap and angle for drawing a dyad.
Colormap and angle depend on the dyad name.
Required arguments:
----------
*dyad*:
Dyad's name. Possible values:
{"primary": ['love', 'submission', 'alarm', 'disappointment', 'remorse', 'contempt', 'aggression', 'optimism'],
"secondary": ['guilt', 'curiosity', 'despair', '', 'envy', 'cynism', 'pride', 'fatalism'],
"tertiary": ['delight', 'sentimentality', 'shame', 'outrage', 'pessimism', 'morbidness', 'dominance', 'anxiety']}
Returns:
----------
*colormap*:
Matplotlib colormap for the dyad. See: https://matplotlib.org/3.1.0/gallery/color/named_colors.html
*angle*:
Each subsequent dyad is rotated 45° around the origin.
"""
# PRIMARY DYADS
if dyad == 'love':
cmap = ['gold', 'olivedrab']
angle = -45 / 2
emos = ['joy', 'trust']
level = 1
elif dyad == 'submission':
cmap = ['olivedrab', 'forestgreen']
angle = (-45 / 2) + (-45)
emos = ['trust', 'fear']
level = 1
elif dyad == 'alarm':
cmap = ['forestgreen', 'skyblue']
angle = (-45 / 2) + (-90)
emos = ['fear', 'surprise']
level = 1
elif dyad == 'disappointment':
cmap = ['skyblue', 'dodgerblue']
angle = (-45 / 2) + (-135)
emos = ['surprise', 'sadness']
level = 1
elif dyad == 'remorse':
cmap = ['dodgerblue', 'slateblue']
angle = (-45 / 2) + (-180)
emos = ['sadness', 'disgust']
level = 1
elif dyad == 'contempt':
cmap = ['slateblue', 'orangered']
angle = (-45 / 2) + (-225)
emos = ['disgust', 'anger']
level = 1
elif dyad == 'aggressiveness':
cmap = ['orangered', 'darkorange']
angle = (-45 / 2) + (-270)
emos = ['anger', 'anticipation']
level = 1
elif dyad == 'optimism':
cmap = ['darkorange', 'gold']
angle = (-45 / 2) + (-315)
emos = ['anticipation', 'joy']
level = 1
# SECONDARY DYADS
elif dyad == 'guilt':
cmap = ['gold', 'forestgreen']
angle = -45
emos = ['joy', 'fear']
level = 2
elif dyad == 'curiosity':
cmap = ['olivedrab', 'skyblue']
angle = -90
emos = ['trust', 'surprise']
level = 2
elif dyad == 'despair':
cmap = ['forestgreen', 'dodgerblue']
angle = -135
emos = ['fear', 'sadness']
level = 2
elif dyad == 'unbelief':
cmap = ['skyblue', 'slateblue']
angle = -180
emos = ['surprise', 'disgust']
level = 2
elif dyad == 'envy':
cmap = ['dodgerblue', 'orangered']
angle = -225
emos = ['sadness', 'anger']
level = 2
elif dyad == 'cynism':
cmap = ['slateblue', 'darkorange']
angle = -270
emos = ['disgust', 'anticipation']
level = 2
elif dyad == 'pride':
cmap = ['orangered', 'gold']
angle = -315
emos = ['anger', 'joy']
level = 2
elif dyad == 'hope':
cmap = ['darkorange', 'olivedrab']
angle = 0
emos = ['anticipation', 'trust']
level = 2
# TERTIARY DYADS
elif dyad == 'delight':
cmap = ['gold', 'skyblue']
angle = (-45 / 2) + (-45)
emos = ['joy', 'surprise']
level = 3
elif dyad == 'sentimentality':
cmap = ['olivedrab', 'dodgerblue']
angle = (-45 / 2) + (-90)
emos = ['trust', 'sadness']
level = 3
elif dyad == 'shame':
cmap = ['forestgreen', 'slateblue']
angle = (-45 / 2) + (-135)
emos = ['fear', 'disgust']
level = 3
elif dyad == 'outrage':
cmap = ['skyblue', 'orangered']
angle = (-45 / 2) + (-180)
emos = ['surprise', 'anger']
level = 3
elif dyad == 'pessimism':
cmap = ['dodgerblue', 'darkorange']
angle = (-45 / 2) + (-225)
emos = ['sadness', 'anticipation']
level = 3
elif dyad == 'morbidness':
cmap = ['slateblue', 'gold']
angle = (-45 / 2) + (-270)
emos = ['disgust', 'joy']
level = 3
elif dyad == 'dominance':
cmap = ['orangered', 'olivedrab']
angle = (-45 / 2) + (-315)
emos = ['anger', 'trust']
level = 3
elif dyad == 'anxiety':
cmap = ['darkorange', 'forestgreen']
angle = (-45 / 2)
emos = ['anticipation', 'fear']
level = 3
# OPPOSITES
elif dyad == 'bittersweetness':
cmap = ['gold', 'dodgerblue']
angle = 0
emos = ['joy', 'sadness']
level = 4
elif dyad == 'ambivalence':
cmap = ['olivedrab', 'slateblue']
angle = -45
emos = ['trust', 'disgust']
level = 4
elif dyad == 'frozenness':
cmap = ['forestgreen', 'orangered']
angle = -90
emos = ['fear', 'anger']
level = 4
elif dyad == 'confusion':
cmap = ['skyblue', 'darkorange']
angle = -135
emos = ['surprise', 'anticipation']
level = 4
else:
raise Exception("""Bad input: '{}' is not an accepted name for a dyad.
Must be one of:
'love', 'submission', 'alarm', 'disappointment', 'remorse', 'contempt', 'aggressiveness', 'optimism',
'guilt', 'curiosity', 'despair', 'unbelief', 'envy', 'cynism', 'pride', 'hope',
'delight', 'sentimentality', 'shame', 'outrage', 'pessimism', 'morbidness', 'dominance', 'anxiety',
'bittersweetness', 'ambivalence', 'frozenness', 'confusion'
""".format(dyad))
return emos, cmap, angle, level
def _rotate_point(point, angle):
"""
Rotate a point counterclockwise by a given angle around a given origin.
Required arguments:
----------
*point*:
A two-values tuple, (x, y), of the point to rotate
*angle*:
The angle the point is rotated. The angle should be given in radians.
Returns:
----------
*(qx, qy)*:
A two-values tuple, the new coordinates of the rotated point.
"""
ox, oy = 0, 0
px, py = point
angle = radians(angle)
qx = ox + cos(angle) * (px - ox) - sin(angle) * (py - oy)
qy = oy + sin(angle) * (px - ox) + cos(angle) * (py - oy)
return (qx, qy)
def _polar_coordinates(ax, font, fontweight, fontsize, show_ticklabels, ticklabels_angle, ticklabels_size, offset = .15):
"""
Draws polar coordinates as a background.
Required arguments:
----------
*ax*:
Axes to draw the coordinates.
*font*:
Font of text. Default is Montserrat.
*fontweight*:
Font weight of text. Default is light.
*fontsize*:
Font size of text. Default is 15.
*show_ticklabels*:
Boolean, wether to show tick labels under Joy petal. Default is False.
*ticklabels_angle*:
How much to rotate tick labels from y=0. Value should be given in radians. Default is 0.
*ticklabels_size*:
Size of tick labels. Default is 11.
*offset*:
Central neutral circle has radius = .15, and coordinates must start from there.
Returns:
----------
*ax*:
The input Axes modified.
"""
# Lines
for i in range(0, 110, 20):
c = plt.Circle((0, 0), offset + i/100, color = 'grey', alpha = .3, fill = False, zorder = -20)
ax.add_artist(c)
# Tick labels
if show_ticklabels:
for x in np.arange(0.2, 1.2, .2):
a = round(x, 1)
x, y = _rotate_point((0, a + offset), ticklabels_angle) #-.12
ax.annotate(s = str(a), xy = (x, y), fontfamily = font, size = ticklabels_size, fontweight = fontweight, zorder = 8, rotation = ticklabels_angle)
return ax
def _neutral_central_circle(ax, r = .15):
"""
Draws central neutral circle (in grey).
Required arguments:
----------
*ax*:
Axes to draw the coordinates.
*r*:
Radius of the circle. Default is .15.
Returns:
----------
*ax*:
The input Axes modified.
"""
c = sg.Point(0, 0).buffer(r)
ax.add_patch(descartes.PolygonPatch(c, fc='white', ec=(.5, .5, .5, .3), alpha=1, zorder = 15))
return ax
def _outer_border(ax, emotion_score, color, angle, highlight, offset = .15, height_width_ratio = 1, normalize = False):
"""
Draw a the outer border of a petal.
Required arguments:
----------
*ax*:
Axes to draw the coordinates.
*emotion_score*:
Score of the emotion. Values range from 0 to 1.
*color*:
Color of the petal. See emo_params().
*angle*:
Rotation angle of the petal. See emo_params().
*highlight*:
String. 'opaque' if the petal must be shadowed, 'regular' is default.
*offset*:
Central neutral circle has radius = .15, and petals must start from there.
*height_width_ratio*:
Ratio between height and width of the petal. Lower the ratio, thicker the petal. Default is 1.
*normalize*:
Either False or the highest value among emotions. If not False, must normalize all petal lengths.
"""
if normalize:
emotion_score /= normalize
# Computing proportions.
h = 1*emotion_score + offset
x = height_width_ratio*emotion_score
y = h/2
r = sqrt(x**2 + y**2)
# Computing rotated centers
x_right, y_right = _rotate_point((x, y), angle)
x_left, y_left = _rotate_point((-x, y), angle)
# Circles and intersection
right = sg.Point(x_right, y_right).buffer(r)
left = sg.Point(x_left, y_left).buffer(r)
petal = right.intersection(left)
# alpha and color
alpha = 1 if highlight == 'regular' else .8
ecol = (colors.to_rgba(color)[0], colors.to_rgba(color)[1], colors.to_rgba(color)[2], alpha)
ax.add_patch(descartes.PolygonPatch(petal, fc=(0, 0, 0, 0), ec = ecol, lw= 1))
def _petal_shape_emotion(ax, emotion_score, color, angle, font, fontweight, fontsize, highlight, will_circle, offset = .15, height_width_ratio = 1, normalize = False):
"""
Draw a petal.
A petal is the intersection area between two circles.
The height of the petal depends on the radius and the center of the circles.
Full details at http://www.github.com/alfonsosemeraro/plutchik/tutorial.ipynb
Required arguments:
----------
*ax*:
Axes to draw the coordinates.
*emotion_score*:
Score of the emotion. Values range from 0 to 1.
*color*:
Color of the petal. See emo_params().
*angle*:
Rotation angle of the petal. See emo_params().
*font*:
Font of text. Default is Montserrat.
*fontweight*:
Font weight of text. Default is light.
*fontsize*:
Font size of text. Default is 15.
*highlight*:
String. 'opaque' if the petal must be shadowed, 'regular' is default.
*will_circle*:
Boolean. If three intensities will be plotted, then the lower petal must be pale.
*offset*:
Central neutral circle has radius = .15, and petals must start from there.
*height_width_ratio*:
Ratio between height and width of the petal. Lower the ratio, thicker the petal. Default is 1.
*normalize*:
Either False or the highest value among emotions. If not False, must normalize all petal lengths.
Returns:
----------
*petal*:
The petal, a shapely shape.
"""
if normalize:
emotion_score /= normalize
# Computing proportions.
h = 1*emotion_score + offset
x = height_width_ratio*emotion_score
y = h/2
r = sqrt(x**2 + y**2)
# Computing rotated centers
x_right, y_right = _rotate_point((x, y), angle)
x_left, y_left = _rotate_point((-x, y), angle)
# Circles and intersection
right = sg.Point(x_right, y_right).buffer(r)
left = sg.Point(x_left, y_left).buffer(r)
petal = right.intersection(left)
# Alpha for highlighting
if highlight == 'regular':
if will_circle:
alpha = .3
else:
alpha = .5
elif will_circle:
alpha = .0
else:
alpha = .0
ax.add_patch(descartes.PolygonPatch(petal, fc='white', lw = 0, alpha=1, zorder = 0))
ax.add_patch(descartes.PolygonPatch(petal, fc=color, lw= 0, alpha=alpha, zorder = 10))
return petal
def _petal_shape_dyad(ax, emotion_score, colorA, colorB, angle, font, fontweight, fontsize, highlight, will_circle, offset = .15, height_width_ratio = 1, normalize = False):
"""
Draw a petal.
A petal is the intersection area between two circles.
The height of the petal depends on the radius and the center of the circles.
Full details at http://www.github.com/alfonsosemeraro/plutchik/tutorial.ipynb
Required arguments:
----------
*ax*:
Axes to draw the coordinates.
*emotion_score*:
Score of the emotion. Values range from 0 to 1.
*colorA*:
First color of the petal. See dyad_params().
*colorB*:
Second color of the petal. See dyad_params().
*angle*:
Rotation angle of the petal. See dyad_params().
*font*:
Font of text. Default is Montserrat.
*fontweight*:
Font weight of text. Default is light.
*fontsize*:
Font size of text. Default is 15.
*highlight*:
String. 'opaque' if the petal must be shadowed, 'regular' is default.
*will_circle*:
Boolean. If three intensities will be plotted, then the lower petal must be pale.
*offset*:
Central neutral circle has radius = .15, and petals must start from there.
*height_width_ratio*:
Ratio between height and width of the petal. Lower the ratio, thicker the petal. Default is 1.
*normalize*:
Either False or the highest value among emotions. If not False, must normalize all petal lengths.
Returns:
----------
*petal*:
The petal, a shapely shape.
"""
if emotion_score == 0:
return ax
if normalize:
emotion_score /= normalize
# Computing proportions.
h = 1*emotion_score + offset
x = height_width_ratio*emotion_score
y = h/2
r = sqrt(x**2 + y**2)
# Computing rotated centers
x_right, y_right = _rotate_point((x, y), angle)
x_left, y_left = _rotate_point((-x, y), angle)
# Circles and intersection
right = sg.Point(x_right, y_right).buffer(r)
left = sg.Point(x_left, y_left).buffer(r)
petal = right.intersection(left)
# Computing squares: left
A = _rotate_point((-2*x, 0), angle)
B = _rotate_point((-2*x, h), angle)
C = _rotate_point((0, h), angle)
D = _rotate_point((0, 0), angle)
square_left = sg.Polygon([A, B, C, D, A])
# Computing squares: right
A = _rotate_point((0, 0), angle)
B = _rotate_point((0, h), angle)
C = _rotate_point((2*x, h), angle)
D = _rotate_point((2*x, 0), angle)
square_right = sg.Polygon([A, B, C, D, A])
# Computing semipetals
petalA = petal.intersection(square_left)
petalB = petal.intersection(square_right)
# white petal underneath
ax.add_patch(descartes.PolygonPatch(petal, fc='white', lw = 0, alpha=1, zorder = 0))
# Draw each half-petal in alpha 0.7
alpha = .7
xs, ys = petalA.exterior.xy
ax.fill(xs, ys, alpha=alpha, fc= colorA, ec='none')
xs, ys = petalB.exterior.xy
ax.fill(xs, ys, alpha=alpha, fc=colorB, ec='none')
return ax
def _petal_spine_emotion(ax, emotion, emotion_score, color, angle, font, fontweight, fontsize, highlight = 'all', offset = .15):
"""
Draw the spine beneath a petal, and the annotation of emotion and emotion's value.
The spine is a straight line from the center, of length 1.03.
Full details at http://www.github.com/alfonsosemeraro/plutchik/tutorial.ipynb
Required arguments:
----------
*ax*:
Axes to draw the coordinates.
*emotion*:
Emotion's name.
*emotion_score*:
Score of the emotion. Values range from 0 to 1. if list, it must contain 3 values that sum up to 1.
*color*:
Color of the petal. See emo_params().
*angle*:
Rotation angle of the petal. See emo_params().
*font*:
Font of text. Default is Montserrat.
*fontweight*:
Font weight of text. Default is light.
*fontsize*:
Font size of text. Default is 15.
*highlight*:
String. 'opaque' if the petal must be shadowed, 'regular' is default.
*offset*:
Central neutral circle has radius = .15, and petals must start from there.
"""
# Diagonal lines and ticks
step = .03
p1 = (0, 0)
p2 = _rotate_point((0, 1 + step + offset), angle) # draw line until 0, 1 + step + offset
p3 = _rotate_point((-step, 1 + step + offset), angle) # draw tick
ax.plot([p1[0], p2[0]], [p1[1], p2[1]], zorder = 5, color = 'black', alpha = .3, linewidth = .75)
ax.plot([p2[0], p3[0]], [p2[1], p3[1]], zorder = 5, color = 'black', alpha = .3, linewidth = .75)
# Managing highlighting and transparency
if highlight == 'opaque':
alpha = .8
color = 'lightgrey'
else:
alpha = 1
# Checking if iterable
try:
_ = emotion_score[0]
iterable = True
except:
iterable = False
if iterable:
# Label
angle2 = angle + 180 if -110 > angle > -260 else angle
p4 = _rotate_point((0, 1.40 + step + offset), angle)
ax.annotate(s = emotion, xy = p4, rotation = angle2, ha='center', va = 'center',
fontfamily = font, size = fontsize, fontweight = fontweight)
# Score 1
p5 = _rotate_point((0, 1.07 + step + offset), angle)
ax.annotate(s = "{0:.2f}".format(round(emotion_score[0],2)), xy = p5, rotation = angle2, ha='center', va = 'center',
color = color, fontfamily = font, size = fontsize, fontweight = 'regular', alpha = alpha)
# Score 2
p6 = _rotate_point((0, 1.17 + step + offset), angle)
ax.annotate(s = "{0:.2f}".format(round(emotion_score[1],2)), xy = p6, rotation = angle2, ha='center', va = 'center',
color = color, fontfamily = font, size = fontsize, fontweight = 'demibold', alpha = alpha)
# Score 3
p7 = _rotate_point((0, 1.27 + step + offset), angle)
ax.annotate(s = "{0:.2f}".format(round(emotion_score[2],2)), xy = p7, rotation = angle2, ha='center', va = 'center',
color = color, fontfamily = font, size = fontsize, fontweight = 'regular', alpha = alpha)
else:
# Label
angle2 = angle + 180 if -110 > angle > -260 else angle
p4 = _rotate_point((0, 1.23 + step + offset), angle)
ax.annotate(s = emotion, xy = p4, rotation = angle2, ha='center', va = 'center',
fontfamily = font, size = fontsize, fontweight = fontweight)
# Score
p5 = _rotate_point((0, 1.1 + step + offset), angle)
ax.annotate(s = "{0:.2f}".format(round(emotion_score,2)), xy = p5, rotation = angle2, ha='center', va = 'center',
color = color, fontfamily = font, size = fontsize, fontweight = 'demibold', alpha = alpha)
def _petal_spine_dyad(ax, dyad, dyad_score, color, emotion_names, angle, font, fontweight, fontsize, highlight = 'all', offset = .15):
"""
Draw the spine beneath a petal, and the annotation of dyad and dyad's value.
The spine is a straight line from the center, of length 1.03.
Full details at http://www.github.com/alfonsosemeraro/plutchik/tutorial.ipynb
Required arguments:
----------
*ax*:
Axes to draw the coordinates.
*dyad*:
Dyad's name.
*dyad_score*:
Score of the dyad. Values range from 0 to 1. if list, it must contain 3 values that sum up to 1.
*color*:
Color of the two emotions of the dyad. See dyad_params().
*emotion_names*:
Name of the emotions the dyad is made of. See dyad_params().
*angle*:
Rotation angle of the petal. See dyad_params().
*font*:
Font of text. Default is Montserrat.
*fontweight*:
Font weight of text. Default is light.
*fontsize*:
Font size of text. Default is 15.
*highlight*:
String. 'opaque' if the petal must be shadowed, 'regular' is default.
*offset*:
Central neutral circle has radius = .15, and petals must start from there.
"""
# Diagonal lines and ticks
step = .03
p1 = (0, 0) # 0, 0 + offset
p2 = _rotate_point((0, 1 + step + offset), angle) # draw line until 0, 1 + step + offset
p3 = _rotate_point((-step, 1 + step + offset), angle) # draw tick
ax.plot([p1[0], p2[0]], [p1[1], p2[1]], zorder = 5, color = 'black', alpha = .3, linewidth = .75)
ax.plot([p2[0], p3[0]], [p2[1], p3[1]], zorder = 5, color = 'black', alpha = .3, linewidth = .75)
# Managing highlighting and opacity
if highlight == 'opaque':
alpha = .8
color = 'lightgrey'
else:
alpha = 1
## Drawing the two-colored circular arc over dyads
from matplotlib.patches import Arc
H = 3.2
pac1 = Arc((0, 0), width = H, height = H, angle = 90, theta2 = angle, theta1 = angle - 18, ec = color[1], linewidth = 3)
pac2 = Arc((0, 0), width = H, height = H, angle = 90, theta2 = angle + 18, theta1 = angle, ec = color[0], linewidth = 3)
ax.add_patch(pac1)
ax.add_patch(pac2)
# Labels over the arcs
angle2 = angle + 180 if -110 > angle > -260 else angle
p9 = _rotate_point((0, 1.7), angle - 9)
ax.annotate(s = emotion_names[1], xy = p9, rotation = angle2 - 8, ha='center', va = 'center', zorder = 30,
fontfamily = font, size = fontsize * .7, fontweight = 'demibold', color = color[1])
p10 = _rotate_point((0, 1.7), angle + 9)
ax.annotate(s = emotion_names[0], xy = p10, rotation = angle2 + 8, ha='center', va = 'center', zorder = 30,
fontfamily = font, size = fontsize * .7, fontweight = 'demibold', color = color[0])
# Dyad label must be grey
color = '#363636'
# Label
angle2 = angle + 180 if -110 > angle > -260 else angle
p4 = _rotate_point((0, 1.23 + step + offset), angle)
ax.annotate(s = dyad, xy = p4, rotation = angle2, ha='center', va = 'center',
fontfamily = font, size = fontsize, fontweight = fontweight)
# Score
p5 = _rotate_point((0, 1.1 + step + offset), angle)
ax.annotate(s = "{0:.2f}".format(round(dyad_score,2)), xy = p5, rotation = angle2, ha='center', va = 'center',
color = color, fontfamily = font, size = fontsize, fontweight = 'demibold', alpha = alpha)
def _petal_circle(ax, petal, radius, color, inner = False, highlight = 'none', offset = .15, normalize = False):
"""
Each petal may have 3 degrees of intensity.
Each of the three sections of a petal is the interception between
the petal and up to two concentric circles from the origin.
This function draws one section.
Full details at http://www.github.com/alfonsosemeraro/plutchik/tutorial.ipynb
Required arguments:
----------
*ax*:
Axes to draw the coordinates.
*petal*:
The petal shape. See petal().
*radius*:
Radius of the section.
*color*:
Color of the section. See emo_params().
*inner*:
Boolean. If True, a second patch is drawn with alpha = 0.3, making the inner circle darker.
*highlight*:
String. 'opaque' if the petal must be shadowed, 'regular' is default.
*offset*:
Central neutral circle has radius = .15, and petals must start from there.
*normalize*:
Either False or the highest value among emotions. If not False, must normalize all petal lengths.
"""
if radius:
if normalize:
radius /= normalize
# Define the intersection between circle c and petal
c = sg.Point(0, 0).buffer(radius + offset)
area = petal.intersection(c)
# Managing alpha and color
alpha0 = 1 if highlight == 'regular' else .2
ecol = (colors.to_rgba(color)[0], colors.to_rgba(color)[1], colors.to_rgba(color)[2], alpha0)
alpha1 = .5 if highlight == 'regular' else .0
# Drawing separately the shape and a thicker border
ax.add_patch(descartes.PolygonPatch(area, fc=color, ec = 'black', lw = 0, alpha=alpha1))
ax.add_patch(descartes.PolygonPatch(area, fc=(0, 0, 0, 0), ec = ecol, lw = 1.3))
# The innermost circle gets to be brighter because of the repeated overlap
# Its alpha is diminished to avoid too much bright colors
if inner:
alpha2 = .3 if highlight == 'regular' else .0
ax.add_patch(descartes.PolygonPatch(area, fc=color, ec = 'w', lw = 0, alpha=alpha2))
ax.add_patch(descartes.PolygonPatch(area, fc=(0, 0, 0, 0), ec = ecol, lw = 1.5))
def _draw_emotion_petal(ax, emotion, emotion_score, highlight_emotions, show_intensity_labels, font, fontweight, fontsize, show_coordinates, height_width_ratio, normalize = False):
"""
Draw the petal and its possible sections.
Full details at http://www.github.com/alfonsosemeraro/plutchik/tutorial.ipynb
Required arguments:
----------
*ax*:
Axes to draw the coordinates.
*emotion*:
Emotion's name.
*emotion_score*:
Score of the emotion. Values range from 0 to 1.
*highlight_emotions*:
A list of main emotions to highlight. Other emotions will be shadowed.
*show_intensity_labels*:
A string or a list of main emotions. It shows all three intensity scores for each emotion in the list, and for the others cumulative scores. Default is 'none'.
*font*:
Font of text. Default is Montserrat.
*fontweight*:
Font weight of text. Default is light.
*fontsize*:
Font size of text. Default is 15.
*offset*:
Central neutral circle has radius = .15, and petals must start from there.
*show_coordinates*:
A boolean, wether to show polar coordinates or not.
*normalize*:
Either False or the highest value among emotions. If not False, normalize petal length.
"""
color, angle, _ = emo_params(emotion)
# Check if iterable
try:
_ = emotion_score[0]
iterable = True
except:
iterable = False
# Manage highlight and opacity
if highlight_emotions != 'all':
if emotion in highlight_emotions:
highlight = 'regular'
else:
highlight = 'opaque'
else:
highlight = 'regular'
if not iterable:
if show_coordinates:
# Draw the line and tick behind a petal
_petal_spine_emotion(ax = ax, emotion = emotion, emotion_score = emotion_score,
color = color, angle = angle,
font = font, fontweight = fontweight, fontsize = fontsize,
highlight = highlight,
offset = .15)
# Draw petal
_petal_shape_emotion(ax, emotion_score, color, angle, font, fontweight, fontsize, height_width_ratio = height_width_ratio, highlight = highlight, will_circle = False, normalize = normalize)
# Draw border
_outer_border(ax, emotion_score, color, angle, height_width_ratio = height_width_ratio, highlight = highlight, normalize = normalize)
else:
# Total length is the sum of the emotion score
a, b, c = emotion_score
length = a + b + c
# Show three scores or just the cumulative one?
label = emotion_score if ((show_intensity_labels == 'all') or (emotion in show_intensity_labels)) else length
if show_coordinates:
# Draw the line and tick behind a petal
_petal_spine_emotion(ax = ax, emotion = emotion, emotion_score = label,
color = color, angle = angle,
font = font, fontweight = fontweight, fontsize = fontsize,
highlight = highlight,
offset = .15)
# Draw petal
petal_shape = _petal_shape_emotion(ax, length, color, angle, font, fontweight, fontsize, height_width_ratio = height_width_ratio, highlight = highlight, will_circle = True, normalize = normalize)
# Draw inner petal section
_petal_circle(ax, petal_shape, a + b, color, False, highlight, normalize = normalize)
# Draw middle petal section
_petal_circle(ax, petal_shape, a, color, True, highlight, normalize = normalize)
# Draw border
_outer_border(ax, length, color, angle, height_width_ratio = height_width_ratio, highlight = highlight, normalize = normalize)
def _draw_dyad_petal(ax, dyad, dyad_score, font, fontweight, fontsize, show_coordinates, height_width_ratio, offset = .15, normalize = False):
"""
Draw the petal and its possible sections.
Full details at http://www.github.com/alfonsosemeraro/plutchik/tutorial.ipynb
Required arguments:
----------
*ax*:
Axes to draw the coordinates.
*dyad*:
Dyad's name.
*dyad_score*:
Score of the dyad. Values range from 0 to 1.
*font*:
Font of text. Default is Montserrat.
*fontweight*:
Font weight of text. Default is light.
*fontsize*:
Font size of text. Default is 15.
*offset*:
Central neutral circle has radius = .15, and petals must start from there.
*show_coordinates*:
A boolean, wether to show polar coordinates or not.
*normalize*:
Either False or the highest value among the dyads. If not False, normalize petal length.
"""
emos, color, angle, _ = dyad_params(dyad)
colorA, colorB = color
if show_coordinates:
# Draw the line and tick behind a petal
_petal_spine_dyad(ax = ax, dyad = dyad, dyad_score = dyad_score,
emotion_names = emos,
color = color, angle = angle,
font = font, fontweight = fontweight, fontsize = fontsize,
highlight = 'all',
offset = .15)
# Draw petal (and get the modified ax)
ax = _petal_shape_dyad(ax, dyad_score, colorA, colorB, angle, font, fontweight, fontsize, height_width_ratio = height_width_ratio, highlight = 'all', will_circle = False, normalize = normalize)
# Draw border
_outer_border(ax, dyad_score, colorA, angle, height_width_ratio = height_width_ratio, highlight = 'all', normalize = normalize)
def _check_scores_kind(tags):
"""
Checks if the inputed scores are all of the same kind
(emotions or primary dyads or secondary dyads or tertiary dyads or opposites).
No mixed kinds are allowed.
Required arguments:
----------
*tags*:
List of the tags provided as 'scores'.
Returns:
----------
A boolean, True if `scores` contains emotions, False if it contains dyads.
"""
kinds = []
for t in tags:
try:
kinds += [emo_params(t)[2]]
except:
kinds += [dyad_params(t)[3]]
unique_kinds = list(set(sorted(kinds)))
if len(unique_kinds) > 1:
unique_kinds_str = ', '.join([str(a) for a in unique_kinds])
unique_kinds_str = unique_kinds_str.replace('0', 'emotions')
unique_kinds_str = unique_kinds_str.replace('1', 'primary dyads')
unique_kinds_str = unique_kinds_str.replace('2', 'secondary dyads')
unique_kinds_str = unique_kinds_str.replace('3', 'tertiary dyads')
unique_kinds_str = unique_kinds_str.replace('4', 'opposite emotions')
unique_kinds_str = ' and'.join(unique_kinds_str.rsplit(',', 1))
error_str = "Bad input: can't draw {} altogether. Please input only one of them as 'scores'.".format(unique_kinds_str)
raise Exception(error_str)
else:
kind = kinds[0]
if kind == 0:
return True
else:
return False
def random_flower():
""" Draws a Plutchik's flower with random scores """
import random
emo = {'joy': random.uniform(0, 1),
'trust': random.uniform(0,1),
'fear': random.uniform(0,1),
'surprise': random.uniform(0,1),
'sadness': random.uniform(0,1),
'disgust': random.uniform(0,1),
'anger': random.uniform(0,1),
'anticipation': random.uniform(0,1)}
plutchik(emo)
def plutchik(scores,
ax = None,
font = None,
fontweight = 'light',
fontsize = 15,
show_coordinates = True,
show_ticklabels = False,
highlight_emotions = 'all',
show_intensity_labels = 'none',
ticklabels_angle = 0,
ticklabels_size = 11,
height_width_ratio = 1,
title = None,
title_size = None,
normalize = False):
"""
Draw the petal and its possible sections.
Full details at http://www.github.com/alfonsosemeraro/plutchik/tutorial.ipynb
Required arguments:
----------
*scores*:
A dictionary with emotions or dyads.
For each entry, values accepted are a 3-values iterable (for emotions only) or a scalar value between 0 and 1.
The sum of the 3-values iterable values must not exceed 1, and no value should be negative.
See emo_params() and dyad_params() for accepted keys.
Emotions and dyads are mutually exclusive. Different kinds of dyads are mutually exclusive.
*ax*:
Axes to draw the coordinates.
*font*:
Font of text. Default is sans-serif.
*fontweight*:
Font weight of text. Default is light.
*fontsize*:
Font size of text. Default is 15.
*offset*:
Central neutral circle has radius = .15, and petals must start from there.
*show_coordinates*:
A boolean, wether to show polar coordinates or not.
*show_ticklabels*:
Boolean, wether to show tick labels under Joy petal. Default is False.
*highlight_emotions*:
A string or a list of main emotions to highlight. If a list of emotions is given, other emotions will be shadowed. Default is 'all'.
*show_intensity_labels*:
A string or a list of main emotions. It shows all three intensity scores for each emotion in the list, and for the others cumulative scores. Default is 'none'.
*ticklabels_angle*:
How much to rotate tick labels from y=0. Value should be given in radians. Default is 0.
*ticklabels_size*:
Size of tick labels. Default is 11.
*height_width_ratio*:
Ratio between height and width of the petal. Lower the ratio, thicker the petal. Default is 1.
*title*:
Title for the plot.
*title_size*:
Size of the title. Default is font_size.
Returns:
----------
*ax*:
The input Axes modified.
"""
scores = {key.lower(): val for key, val in scores.items()}
# Check if dyads or emotions, and what kind of dyads
score_is_emotions = _check_scores_kind(scores)
if score_is_emotions:
emotions, dyads = scores, None
else:
emotions, dyads = None, scores
# Create subplot if is not provided as parameter
if not ax:
fig, ax = plt.subplots(figsize = (8, 8))
# Managing fonts
if not font:
font = 'sans-serif'
# Draw coordinates (if needed) before any petal
if show_coordinates:
_polar_coordinates(ax, font, fontweight, fontsize, show_ticklabels, ticklabels_angle, ticklabels_size)
# Draw inner white circle
_neutral_central_circle(ax)
# Emotions and dyads are mutually exclusive
if emotions:
emotions = {key.lower(): val for key, val in emotions.items()}
for emo in emotions:
# Check correctedness of values
if hasattr(emotions[emo], '__iter__'):
if sum(emotions[emo]) > 1 or any([e < 0 for e in emotions[emo]]):
raise Exception("Bad input for `{}`. Emotion scores array should be between 0 and 1.".format(emo))
else:
if emotions[emo] > 1 or emotions[emo] < 0:
raise Exception("Bad input for `{}`. Emotion scores array should sum to between 0 and 1.".format(emo))
# Draw emotion petal
_draw_emotion_petal(ax, emotion_score = emotions[emo], emotion = emo,
font = font, fontweight = fontweight, fontsize = fontsize,
highlight_emotions = highlight_emotions, show_intensity_labels = show_intensity_labels,
show_coordinates = show_coordinates, height_width_ratio = height_width_ratio, normalize = normalize)
elif dyads:
for dyad in dyads:
# Check correctedness of values
if dyads[dyad] > 1 or dyads[dyad] < 0:
print("Alert: {} = {}".format(dyad, dyads[dyad]))
raise Exception("Bad input for `{}`. Dyads scores array should sum to between 0 and 1.".format(dyad))
# Draw dyad bicolor petal
_draw_dyad_petal(ax, dyad_score = dyads[dyad], dyad = dyad,
font = font, fontweight = fontweight, fontsize = fontsize,
show_coordinates = show_coordinates, height_width_ratio = height_width_ratio,
normalize = normalize)
# Annotation inside the circle
_, _, _, level = dyad_params(list(dyads.keys())[0]) # get the first dyad level (they all are the same)
ll = level if level != 4 else 'opp.' # what to annotate
xy = (-0.03, -0.03) if level != 4 else (-0.13, -0.03) # exact center of '1' or 'opp' is slightly different
ax.annotate(s = ll, xy = xy, fontsize = fontsize, fontfamily = font, fontweight = 'bold', zorder = 30)
# Ghost dotted track that connects colored arcs
c = plt.Circle((0, 0), 1.60, color = 'grey', alpha = .3, fill = False, zorder = -20, linestyle = 'dotted' )
ax.add_artist(c)
# Adjusting printable area size
lim = 1.6 if show_coordinates else 1.2
lim = lim + 0.1 if dyads else lim
ax.set_xlim((-lim, lim))
ax.set_ylim((-lim, lim))
# Default is no axis
ax.axis('off')
# Title and title size
if not title_size:
title_size = fontsize
if title:
ax.set_title(title, fontfamily = font, fontsize = title_size, fontweight = 'bold', pad = 20)
return ax