Updated Angles on Bracket arrow styles example

jvcsir · jvcsir · commit be2a1a315465 · 2022-10-12T15:30:56.000+02:00
diff --git a/doc/users/prev_whats_new/whats_new_3.4.0.rst b/doc/users/prev_whats_new/whats_new_3.4.0.rst
@@ -371,22 +371,215 @@ Angles specified on the *Bracket* arrow styles (``]-[``, ``]-``, ``-[``, or
 applied. Previously, the *angleA* and *angleB* options were allowed, but did
 nothing.
 
+Angles are annotated using ``AngleAnnotation`` from the example
+:doc:`/gallery/text_labels_and_annotations/angle_annotation`. `.FancyArrowPatch`
+arrows are added to show the directions of *angleA* and *angleB*.
+
 .. plot::
 
-    import matplotlib.patches as mpatches
+    import matplotlib.pyplot as plt
+    import numpy as np
+    from matplotlib.patches import Arc, FancyArrowPatch
+    from matplotlib.transforms import Bbox, IdentityTransform, TransformedBbox
 
-    fig, ax = plt.subplots()
-    ax.set(xlim=(0, 1), ylim=(-1, 4))
-
-    for i, stylename in enumerate((']-[', '|-|')):
-        for j, angle in enumerate([-30, 60]):
-            arrowstyle = f'{stylename},angleA={angle},angleB={-angle}'
-            patch = mpatches.FancyArrowPatch((0.1, 2*i + j), (0.9, 2*i + j),
-                                             arrowstyle=arrowstyle,
-                                             mutation_scale=25)
-            ax.text(0.5, 2*i + j, arrowstyle,
-                    verticalalignment='bottom', horizontalalignment='center')
+
+    class AngleAnnotation(Arc):
+        """
+        Draws an arc between two vectors which appears circular in display space.
+        """
+        def __init__(self, xy, p1, p2, size=75, unit="points", ax=None,
+                    text="", textposition="inside", text_kw=None, **kwargs):
+            """
+            Parameters
+            ----------
+            xy, p1, p2 : tuple or array of two floats
+                Center position and two points. Angle annotation is drawn between
+                the two vectors connecting *p1* and *p2* with *xy*, respectively.
+                Units are data coordinates.
+
+            size : float
+                Diameter of the angle annotation in units specified by *unit*.
+
+            unit : str
+                One of the following strings to specify the unit of *size*:
+
+                * "pixels": pixels
+                * "points": points, use points instead of pixels to not have a
+                dependence on the DPI
+                * "axes width", "axes height": relative units of Axes width, height
+                * "axes min", "axes max": minimum or maximum of relative Axes
+                width, height
+
+            ax : `matplotlib.axes.Axes`
+                The Axes to add the angle annotation to.
+
+            text : str
+                The text to mark the angle with.
+
+            textposition : {"inside", "outside", "edge"}
+                Whether to show the text in- or outside the arc. "edge" can be used
+                for custom positions anchored at the arc's edge.
+
+            text_kw : dict
+                Dictionary of arguments passed to the Annotation.
+
+            **kwargs
+                Further parameters are passed to `matplotlib.patches.Arc`. Use this
+                to specify, color, linewidth etc. of the arc.
+
+            """
+            self.ax = ax or plt.gca()
+            self._xydata = xy  # in data coordinates
+            self.vec1 = p1
+            self.vec2 = p2
+            self.size = size
+            self.unit = unit
+            self.textposition = textposition
+
+            super().__init__(self._xydata, size, size, angle=0.0,
+                            theta1=self.theta1, theta2=self.theta2, **kwargs)
+
+            self.set_transform(IdentityTransform())
+            self.ax.add_patch(self)
+
+            self.kw = dict(ha="center", va="center",
+                        xycoords=IdentityTransform(),
+                        xytext=(0, 0), textcoords="offset points",
+                        annotation_clip=True)
+            self.kw.update(text_kw or {})
+            self.text = ax.annotate(text, xy=self._center, **self.kw)
+
+        def get_size(self):
+            factor = 1.
+            if self.unit == "points":
+                factor = self.ax.figure.dpi / 72.
+            elif self.unit[:4] == "axes":
+                b = TransformedBbox(Bbox.unit(), self.ax.transAxes)
+                dic = {"max": max(b.width, b.height),
+                    "min": min(b.width, b.height),
+                    "width": b.width, "height": b.height}
+                factor = dic[self.unit[5:]]
+            return self.size * factor
+
+        def set_size(self, size):
+            self.size = size
+
+        def get_center_in_pixels(self):
+            """return center in pixels"""
+            return self.ax.transData.transform(self._xydata)
+
+        def set_center(self, xy):
+            """set center in data coordinates"""
+            self._xydata = xy
+
+        def get_theta(self, vec):
+            vec_in_pixels = self.ax.transData.transform(vec) - self._center
+            return np.rad2deg(np.arctan2(vec_in_pixels[1], vec_in_pixels[0]))
+
+        def get_theta1(self):
+            return self.get_theta(self.vec1)
+
+        def get_theta2(self):
+            return self.get_theta(self.vec2)
+
+        def set_theta(self, angle):
+            pass
+
+        # Redefine attributes of the Arc to always give values in pixel space
+        _center = property(get_center_in_pixels, set_center)
+        theta1 = property(get_theta1, set_theta)
+        theta2 = property(get_theta2, set_theta)
+        width = property(get_size, set_size)
+        height = property(get_size, set_size)
+
+        # The following two methods are needed to update the text position.
+        def draw(self, renderer):
+            self.update_text()
+            super().draw(renderer)
+
+        def update_text(self):
+            c = self._center
+            s = self.get_size()
+            angle_span = (self.theta2 - self.theta1) % 360
+            angle = np.deg2rad(self.theta1 + angle_span / 2)
+            r = s / 2
+            if self.textposition == "inside":
+                r = s / np.interp(angle_span, [60, 90, 135, 180],
+                                            [3.3, 3.5, 3.8, 4])
+            self.text.xy = c + r * np.array([np.cos(angle), np.sin(angle)])
+            if self.textposition == "outside":
+                def R90(a, r, w, h):
+                    if a < np.arctan(h/2/(r+w/2)):
+                        return np.sqrt((r+w/2)**2 + (np.tan(a)*(r+w/2))**2)
+                    else:
+                        c = np.sqrt((w/2)**2+(h/2)**2)
+                        T = np.arcsin(c * np.cos(np.pi/2 - a + np.arcsin(h/2/c))/r)
+                        xy = r * np.array([np.cos(a + T), np.sin(a + T)])
+                        xy += np.array([w/2, h/2])
+                        return np.sqrt(np.sum(xy**2))
+
+                def R(a, r, w, h):
+                    aa = (a % (np.pi/4))*((a % (np.pi/2)) <= np.pi/4) + \
+                        (np.pi/4 - (a % (np.pi/4)))*((a % (np.pi/2)) >= np.pi/4)
+                    return R90(aa, r, *[w, h][::int(np.sign(np.cos(2*a)))])
+
+                bbox = self.text.get_window_extent()
+                X = R(angle, r, bbox.width, bbox.height)
+                trans = self.ax.figure.dpi_scale_trans.inverted()
+                offs = trans.transform(((X-s/2), 0))[0] * 72
+                self.text.set_position([offs*np.cos(angle), offs*np.sin(angle)])
+
+
+    def get_point_of_rotated_vertical(origin, line_length, degrees):
+        """
+        Return xy coordinates of the end of a vertical line rotated by degrees.
+        """
+        rad = np.deg2rad(-degrees)
+        return [origin[0] + line_length * np.sin(rad),
+                origin[1] + line_length * np.cos(rad)]
+
+
+    fig, ax = plt.subplots(figsize=(8, 7))
+    ax.set(xlim=(0, 6), ylim=(-1, 4))
+
+    for i, stylename in enumerate(["]-[", "|-|"]):
+        for j, angle in enumerate([-40, 60]):
+            y = 2*i + j
+            arrow_centers = [(1, y), (5, y)]
+            vlines = [[c[0], y + 0.5] for c in arrow_centers]
+            arrowstyle = f"{stylename},widthA=1.5,widthB=1.5,angleA={angle},angleB={-angle}"
+            patch = FancyArrowPatch(arrow_centers[0], arrow_centers[1],
+                                    arrowstyle=arrowstyle, mutation_scale=25)
             ax.add_patch(patch)
+            ax.text(3, y + 0.05, arrowstyle.replace('widthA=1.5,widthB=1.5,', ''),
+                    verticalalignment="bottom", horizontalalignment="center")
+            ax.vlines([i[0] for i in vlines], [y, y], [i[1] for i in vlines],
+                        linestyles="--", color="C0")
+            # Get the coordinates for the drawn patches at A and B
+            patch_top_coords = [get_point_of_rotated_vertical(arrow_centers[0], 0.5, angle),
+                                get_point_of_rotated_vertical(arrow_centers[1], 0.5, -angle)]
+            # Create points for annotating A and B with AngleAnnotation
+            # Points include the top of the vline and patch_top_coords
+            pointsA =[(1, y + 0.5), patch_top_coords[0]]
+            pointsB = [patch_top_coords[1], (5, y + 0.5)]
+            # Define the directions for the arrows for the direction of AngleAnnotation
+            arrow_angles = [0.5, -0.5]
+            # Reverse the points and arrow_angles when the angle is negative
+            if angle < 0:
+                pointsA.reverse()
+                pointsB.reverse()
+                arrow_angles.reverse()
+            # Add AngleAnnotation and arrows to show angle directions
+            data = zip(arrow_centers, [pointsA, pointsB], vlines, arrow_angles,
+                       patch_top_coords)
+            for center, points, vline, arrow_angle, patch_top in data:
+                am = AngleAnnotation(center, points[0], points[1], ax=ax, size=0.25,
+                                     unit="axes min", text=str(-angle))
+                arrowstyle = "Simple, tail_width=0.5, head_width=4, head_length=8"
+                kw = dict(arrowstyle=arrowstyle, color="C0")
+                arrow = FancyArrowPatch(vline, patch_top,
+                                        connectionstyle=f"arc3,rad={arrow_angle}", **kw)
+                ax.add_patch(arrow)
 
 ``TickedStroke`` patheffect
 ---------------------------
