# -*- coding: utf-8 -*-
'''
Module Name : curlyBrace
Author : 高斯羽 博士 (Dr. GAO, Siyu)
Version : 1.0.2
Last Modified : 2019-04-22
This module is basically an Python implementation of the function written Pål Næverlid Sævik
for MATLAB (link in Reference).
The function "curlyBrace" allows you to plot an optionally annotated curly bracket between
two points when using matplotlib.
The usual settings for line and fonts in matplotlib also apply.
The function takes the axes scales into account automatically. But when the axes aspect is
set to "equal", the auto switch should be turned off.
Change Log
----------------------
* **Notable changes:**
+ Version : 1.0.2
- Added considerations for different scaled axes and log scale
+ Version : 1.0.1
- First version.
Reference
----------------------
https://uk.mathworks.com/matlabcentral/fileexchange/38716-curly-brace-annotation
List of functions
----------------------
* getAxSize_
* curlyBrace_
'''
import matplotlib.pyplot as plt
import numpy as np
[docs]def getAxSize(fig, ax):
'''
.. _getAxSize :
Get the axes size in pixels.
Parameters
----------
fig : matplotlib figure object
The of the target axes.
ax : matplotlib axes object
The target axes.
Returns
-------
ax_width : float
The axes width in pixels.
ax_height : float
The axes height in pixels.
Reference
-----------
https://stackoverflow.com/questions/19306510/determine-matplotlib-axis-size-in-pixels
'''
bbox = ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
ax_width, ax_height = bbox.width, bbox.height
ax_width *= fig.dpi
ax_height *= fig.dpi
return ax_width, ax_height
[docs]def curlyBrace(fig, ax, p1, p2, k_r=0.1, bool_auto=True, str_text='', int_line_num=2, fontdict={}, **kwargs):
# def curlyBrace(fig, ax, p1, p2, k_r=0.1, bool_auto=True, str_text='', int_line_num=2, fontdict={}, **kwargs):
'''
.. _curlyBrace :
Plot an optionally annotated curly bracket on the given axes of the given figure.
Note that the brackets are anti-clockwise by default. To reverse the text position, swap
"p1" and "p2".
Note that, when the axes aspect is not set to "equal", the axes coordinates need to be
transformed to screen coordinates, otherwise the arcs may not be seeable.
Parameters
----------
fig : matplotlib figure object
The of the target axes.
ax : matplotlib axes object
The target axes.
p1 : two element numeric list
The coordinates of the starting point.
p2 : two element numeric list
The coordinates of the end point.
k_r : float
This is the gain controlling how "curvy" and "pointy" (height) the bracket is.
Note that, if this gain is too big, the bracket would be very strange.
bool_auto : boolean
This is a switch controlling wether to use the auto calculation of axes
scales.
When the two axes do not have the same aspects, i.e., not "equal" scales,
this should be turned on, i.e., True.
When "equal" aspect is used, this should be turned off, i.e., False.
If you do not set this to False when setting the axes aspect to "equal",
the bracket will be in funny shape.
Default = True
str_text : string
The annotation text of the bracket. It would displayed at the mid point
of bracket with the same rotation as the bracket.
By default, it follows the anti-clockwise convention. To flip it, swap
the end point and the starting point.
The appearance of this string can be set by using "fontdict", which follows
the same syntax as the normal matplotlib syntax for font dictionary.
Default = empty string (no annotation)
int_line_num : int
This argument determines how many lines the string annotation is from the summit
of the bracket.
The distance would be affected by the font size, since it basically just a number of
lines appended to the given string.
Default = 2
fontdict : dictionary
This is font dictionary setting the string annotation. It is the same as normal
matplotlib font dictionary.
Default = empty dict
**kwargs : matplotlib line setting arguments
This allows the user to set the line arguments using named arguments that are
the same as in matplotlib.
Returns
-------
theta : float
The bracket angle in radians.
summit : list
The positions of the bracket summit.
arc1 : list of lists
arc1 positions.
arc2 : list of lists
arc2 positions.
arc3 : list of lists
arc3 positions.
arc4 : list of lists
arc4 positions.
Reference
----------
https://uk.mathworks.com/matlabcentral/fileexchange/38716-curly-brace-annotation
'''
pt1 = [None, None]
pt2 = [None, None]
ax_width, ax_height = getAxSize(fig, ax)
ax_xlim = list(ax.get_xlim())
ax_ylim = list(ax.get_ylim())
# log scale consideration
if 'log' in ax.get_xaxis().get_scale():
if p1[0] > 0.0:
pt1[0] = np.log(p1[0])
elif p1[0] < 0.0:
pt1[0] = -np.log(abs(p1[0]))
else:
pt1[0] = 0.0
if p2[0] > 0.0:
pt2[0] = np.log(p2[0])
elif p2[0] < 0.0:
pt2[0] = -np.log(abs(p2[0]))
else:
pt2[0] = 0
for i in range(0, len(ax_xlim)):
if ax_xlim[i] > 0.0:
ax_xlim[i] = np.log(ax_xlim[i])
elif ax_xlim[i] < 0.0:
ax_xlim[i] = -np.log(abs(ax_xlim[i]))
else:
ax_xlim[i] = 0.0
else:
pt1[0] = p1[0]
pt2[0] = p2[0]
if 'log' in ax.get_yaxis().get_scale():
if p1[1] > 0.0:
pt1[1] = np.log(p1[1])
elif p1[1] < 0.0:
pt1[1] = -np.log(abs(p1[1]))
else:
pt1[1] = 0.0
if p2[1] > 0.0:
pt2[1] = np.log(p2[1])
elif p2[1] < 0.0:
pt2[1] = -np.log(abs(p2[1]))
else:
pt2[1] = 0.0
for i in range(0, len(ax_ylim)):
if ax_ylim[i] > 0.0:
ax_ylim[i] = np.log(ax_ylim[i])
elif ax_ylim[i] < 0.0:
ax_ylim[i] = -np.log(abs(ax_ylim[i]))
else:
ax_ylim[i] = 0.0
else:
pt1[1] = p1[1]
pt2[1] = p2[1]
# get the ratio of pixels/length
xscale = ax_width / abs(ax_xlim[1] - ax_xlim[0])
yscale = ax_height / abs(ax_ylim[1] - ax_ylim[0])
# this is to deal with 'equal' axes aspects
if bool_auto:
pass
else:
xscale = 1.0
yscale = 1.0
# convert length to pixels,
# need to minus the lower limit to move the points back to the origin. Then add the limits back on end.
pt1[0] = (pt1[0] - ax_xlim[0]) * xscale
pt1[1] = (pt1[1] - ax_ylim[0]) * yscale
pt2[0] = (pt2[0] - ax_xlim[0]) * xscale
pt2[1] = (pt2[1] - ax_ylim[0]) * yscale
# calculate the angle
theta = np.arctan2(pt2[1] - pt1[1], pt2[0] - pt1[0])
# calculate the radius of the arcs
r = np.hypot(pt2[0] - pt1[0], pt2[1] - pt1[1]) * k_r
# arc1 centre
x11 = pt1[0] + r * np.cos(theta)
y11 = pt1[1] + r * np.sin(theta)
# arc2 centre
x22 = (pt2[0] + pt1[0]) / 2.0 - 2.0 * r * np.sin(theta) - r * np.cos(theta)
y22 = (pt2[1] + pt1[1]) / 2.0 + 2.0 * r * np.cos(theta) - r * np.sin(theta)
# arc3 centre
x33 = (pt2[0] + pt1[0]) / 2.0 - 2.0 * r * np.sin(theta) + r * np.cos(theta)
y33 = (pt2[1] + pt1[1]) / 2.0 + 2.0 * r * np.cos(theta) + r * np.sin(theta)
# arc4 centre
x44 = pt2[0] - r * np.cos(theta)
y44 = pt2[1] - r * np.sin(theta)
# prepare the rotated
q = np.linspace(theta, theta + np.pi/2.0, 50)
# reverse q
# t = np.flip(q) # this command is not supported by lower version of numpy
t = q[::-1]
# arc coordinates
arc1x = r * np.cos(t + np.pi/2.0) + x11
arc1y = r * np.sin(t + np.pi/2.0) + y11
arc2x = r * np.cos(q - np.pi/2.0) + x22
arc2y = r * np.sin(q - np.pi/2.0) + y22
arc3x = r * np.cos(q + np.pi) + x33
arc3y = r * np.sin(q + np.pi) + y33
arc4x = r * np.cos(t) + x44
arc4y = r * np.sin(t) + y44
# convert back to the axis coordinates
arc1x = arc1x / xscale + ax_xlim[0]
arc2x = arc2x / xscale + ax_xlim[0]
arc3x = arc3x / xscale + ax_xlim[0]
arc4x = arc4x / xscale + ax_xlim[0]
arc1y = arc1y / yscale + ax_ylim[0]
arc2y = arc2y / yscale + ax_ylim[0]
arc3y = arc3y / yscale + ax_ylim[0]
arc4y = arc4y / yscale + ax_ylim[0]
# log scale consideration
if 'log' in ax.get_xaxis().get_scale():
for i in range(0, len(arc1x)):
if arc1x[i] > 0.0:
arc1x[i] = np.exp(arc1x[i])
elif arc1x[i] < 0.0:
arc1x[i] = -np.exp(abs(arc1x[i]))
else:
arc1x[i] = 0.0
for i in range(0, len(arc2x)):
if arc2x[i] > 0.0:
arc2x[i] = np.exp(arc2x[i])
elif arc2x[i] < 0.0:
arc2x[i] = -np.exp(abs(arc2x[i]))
else:
arc2x[i] = 0.0
for i in range(0, len(arc3x)):
if arc3x[i] > 0.0:
arc3x[i] = np.exp(arc3x[i])
elif arc3x[i] < 0.0:
arc3x[i] = -np.exp(abs(arc3x[i]))
else:
arc3x[i] = 0.0
for i in range(0, len(arc4x)):
if arc4x[i] > 0.0:
arc4x[i] = np.exp(arc4x[i])
elif arc4x[i] < 0.0:
arc4x[i] = -np.exp(abs(arc4x[i]))
else:
arc4x[i] = 0.0
else:
pass
if 'log' in ax.get_yaxis().get_scale():
for i in range(0, len(arc1y)):
if arc1y[i] > 0.0:
arc1y[i] = np.exp(arc1y[i])
elif arc1y[i] < 0.0:
arc1y[i] = -np.exp(abs(arc1y[i]))
else:
arc1y[i] = 0.0
for i in range(0, len(arc2y)):
if arc2y[i] > 0.0:
arc2y[i] = np.exp(arc2y[i])
elif arc2y[i] < 0.0:
arc2y[i] = -np.exp(abs(arc2y[i]))
else:
arc2y[i] = 0.0
for i in range(0, len(arc3y)):
if arc3y[i] > 0.0:
arc3y[i] = np.exp(arc3y[i])
elif arc3y[i] < 0.0:
arc3y[i] = -np.exp(abs(arc3y[i]))
else:
arc3y[i] = 0.0
for i in range(0, len(arc4y)):
if arc4y[i] > 0.0:
arc4y[i] = np.exp(arc4y[i])
elif arc4y[i] < 0.0:
arc4y[i] = -np.exp(abs(arc4y[i]))
else:
arc4y[i] = 0.0
else:
pass
# plot arcs
ax.plot(arc1x, arc1y, **kwargs)
ax.plot(arc2x, arc2y, **kwargs)
ax.plot(arc3x, arc3y, **kwargs)
ax.plot(arc4x, arc4y, **kwargs)
# plot lines
ax.plot([arc1x[-1], arc2x[1]], [arc1y[-1], arc2y[1]], **kwargs)
ax.plot([arc3x[-1], arc4x[1]], [arc3y[-1], arc4y[1]], **kwargs)
summit = [arc2x[-1], arc2y[-1]]
if str_text:
int_line_num = int(int_line_num)
str_temp = '\n' * int_line_num
# convert radians to degree and within 0 to 360
ang = np.degrees(theta) % 360.0
if (ang >= 0.0) and (ang <= 90.0):
rotation = ang
str_text = str_text + str_temp
if (ang > 90.0) and (ang < 270.0):
rotation = ang + 180.0
str_text = str_temp + str_text
elif (ang >= 270.0) and (ang <= 360.0):
rotation = ang
str_text = str_text + str_temp
else:
rotation = ang
ax.axes.text(arc2x[-1], arc2y[-1], str_text, ha='center', va='center', rotation=rotation, fontdict=fontdict)
else:
pass
arc1 = [arc1x, arc1y]
arc2 = [arc2x, arc2y]
arc3 = [arc3x, arc3y]
arc4 = [arc4x, arc4y]
return theta, summit, arc1, arc2, arc3, arc4