PySDM_examples.Arabas_et_al_2023.curved_text

  1# https://stackoverflow.com/questions/19353576/curved-text-rendering-in-matplotlib
  2import math
  3
  4import numpy as np
  5from matplotlib import text as mtext
  6
  7
  8class CurvedText(mtext.Text):
  9    """
 10    A text object that follows an arbitrary curve.
 11    """
 12
 13    def __init__(self, x, y, text, axes, **kwargs):
 14        super().__init__(x[0], y[0], " ", **kwargs)
 15
 16        axes.add_artist(self)
 17
 18        ##saving the curve:
 19        self.__x = x
 20        self.__y = y
 21        self.__zorder = self.get_zorder()
 22
 23        ##creating the text objects
 24        self.__Characters = []
 25        for c in text:
 26            if c == " ":
 27                ##make this an invisible 'a':
 28                t = mtext.Text(0, 0, "a")
 29                t.set_alpha(0.0)
 30            else:
 31                t = mtext.Text(0, 0, c, **kwargs)
 32
 33            # resetting unnecessary arguments
 34            t.set_rotation(0)
 35            t.set_zorder(self.__zorder + 1)
 36
 37            self.__Characters.append((c, t))
 38            axes.add_artist(t)
 39
 40    ##overloading some member functions, to assure correct functionality
 41    ##on update
 42    def set_zorder(self, level):
 43        super().set_zorder(level)
 44        self.__zorder = self.get_zorder()
 45        for _, t in self.__Characters:
 46            t.set_zorder(self.__zorder + 1)
 47
 48    def draw(self, renderer, *_, **__):
 49        """
 50        Overload of the Text.draw() function. Do not do
 51        do any drawing, but update the positions and rotation
 52        angles of self.__Characters.
 53        """
 54        self.update_positions(renderer)
 55
 56    def update_positions(self, renderer):
 57        """
 58        Update positions and rotations of the individual text elements.
 59        """
 60
 61        # preparations
 62
 63        ##determining the aspect ratio:
 64        ##from https://stackoverflow.com/a/42014041/2454357
 65
 66        ##data limits
 67        xlim = self.axes.get_xlim()
 68        ylim = self.axes.get_ylim()
 69        ## Axis size on figure
 70        figW, figH = self.axes.get_figure().get_size_inches()
 71        ## Ratio of display units
 72        _, _, w, h = self.axes.get_position().bounds
 73        ##final aspect ratio
 74        aspect = ((figW * w) / (figH * h)) * (ylim[1] - ylim[0]) / (xlim[1] - xlim[0])
 75
 76        # points of the curve in figure coordinates:
 77        x_fig, y_fig = (
 78            np.array(l)
 79            for l in zip(*self.axes.transData.transform(list(zip(self.__x, self.__y))))
 80        )
 81
 82        # point distances in figure coordinates
 83        x_fig_dist = x_fig[1:] - x_fig[:-1]
 84        y_fig_dist = y_fig[1:] - y_fig[:-1]
 85        r_fig_dist = np.sqrt(x_fig_dist**2 + y_fig_dist**2)
 86
 87        # arc length in figure coordinates
 88        l_fig = np.insert(np.cumsum(r_fig_dist), 0, 0)
 89
 90        # angles in figure coordinates
 91        rads = np.arctan2((y_fig[1:] - y_fig[:-1]), (x_fig[1:] - x_fig[:-1]))
 92        degs = np.rad2deg(rads)
 93
 94        rel_pos = 10
 95        for c, t in self.__Characters:
 96            # finding the width of c:
 97            t.set_rotation(0)
 98            t.set_va("center")
 99            bbox1 = t.get_window_extent(renderer=renderer)
100            w = bbox1.width
101            h = bbox1.height
102
103            # ignore all letters that don't fit:
104            if rel_pos + w / 2 > l_fig[-1]:
105                t.set_alpha(0.0)
106                rel_pos += w
107                continue
108
109            if c != " ":
110                t.set_alpha(1.0)
111
112            # finding the two data points between which the horizontal
113            # center point of the character will be situated
114            # left and right indices:
115            il = np.where(rel_pos + w / 2 >= l_fig)[0][-1]
116            ir = np.where(rel_pos + w / 2 <= l_fig)[0][0]
117
118            # if we exactly hit a data point:
119            if ir == il:
120                ir += 1
121
122            # how much of the letter width was needed to find il:
123            used = l_fig[il] - rel_pos
124            rel_pos = l_fig[il]
125
126            # relative distance between il and ir where the center
127            # of the character will be
128            fraction = (w / 2 - used) / r_fig_dist[il]
129
130            ##setting the character position in data coordinates:
131            ##interpolate between the two points:
132            x = self.__x[il] + fraction * (self.__x[ir] - self.__x[il])
133            y = self.__y[il] + fraction * (self.__y[ir] - self.__y[il])
134
135            # getting the offset when setting correct vertical alignment
136            # in data coordinates
137            bbox2 = t.get_window_extent(renderer=renderer)
138
139            bbox1d = self.axes.transData.inverted().transform(bbox1)
140            bbox2d = self.axes.transData.inverted().transform(bbox2)
141            dr = np.array(bbox2d[0] - bbox1d[0])
142
143            # the rotation/stretch matrix
144            rad = rads[il]
145            rot_mat = np.array(
146                [
147                    [math.cos(rad), math.sin(rad) * aspect],
148                    [-math.sin(rad) / aspect, math.cos(rad)],
149                ]
150            )
151
152            ##computing the offset vector of the rotated character
153            drp = np.dot(dr, rot_mat)
154
155            # setting final position and rotation:
156            t.set_position(np.array([x, y]) + drp)
157            t.set_rotation(degs[il])
158
159            t.set_va("center")
160            t.set_ha("center")
161
162            # updating rel_pos to right edge of character
163            rel_pos += w - used