Thanks for picking this up @kyracho! I think it might make sense to adapt your above example into an image comparison test.

@kyracho I'd like to see if I can help with this issue in any way, unsure how to write a test for this but as @rcomer mentioned, the image comparison will probably be helpful, this is similar to what I implemented in the previous thread.

@rcomer Thanks! I’ve added the image comparison test based on that example. Let me know if there is anything you'd like me to adjust.

@vas1l Appreciate the offer! but I think I’ve got it covered for now.

This is an improvement, but it is not perfect in that you can change the theta offset and direction after the error bars are added:

import matplotlib.pyplot as plt
import numpy as np

theta = np.arange(0, 2 * np.pi, np.pi / 8)
r = theta / np.pi / 2 + 0.5

fig = plt.figure(figsize=(10, 10))
ax = fig.add_subplot(projection='polar')
ax.errorbar(theta, r, xerr=0.1, yerr=0.1, capsize=7, fmt="o", c="seagreen")
ax.set_theta_zero_location("N")
ax.set_theta_direction(-1)
ax.set_title("Pretty polar error bars")
plt.show()

and then it is broken again:

However, I had not realized that we have a cut-out for polar plots in errorbar. In that case, we should grab the transShift transform (or one of the private ones that make it up), which contains theta offset and direction and will automatically update as a normal transform does.

@QuLogic

Thanks for the suggestion! I initially noticed the behavior too. I’ve tried using transShift transform as you recommended, like this:

 if self.name == 'polar':
            trans_shift = self.transShift
            for axis in caplines:
                for l in caplines[axis]:
                    for theta, r in zip(l.get_xdata(), l.get_ydata()):
                        # Apply the transShift transformation to adjust theta
                        transformed_coords = trans_shift.transform([theta, r])
                        adjusted_theta = transformed_coords[0]  # Extract the transformed theta

                        # Apply rotation based on the transformed theta
                        if axis == 'y':
                            rotation = mtransforms.Affine2D().rotate(adjusted_theta - np.pi / 2)
                        else:
                            rotation = mtransforms.Affine2D().rotate(adjusted_theta)

                        # Apply the marker style with the adjusted rotation
                        ms = mmarkers.MarkerStyle(marker=marker, transform=rotation)
                        self.add_line(mlines.Line2D([theta], [r], marker=ms, **eb_cap_style))
        else:
            for axis in caplines:
                for l in caplines[axis]:
                    self.add_line(l)

While it does contain the theta_offset and theta_direction and correctly adjusts theta, the issue I'm encountering is that it doesn’t retroactively apply to the error bars if ax.errorbar() is called before setting theta_zero_location or theta_direction.

The reason for this is that while transShift dynamically updates for other plot elements, it doesn’t retroactively change error bars unless ax.errorbar() is called again or the error bars are manually updated.

Let me know if you have any thoughts or further suggestions on how we could potentially address this!

General note:

I haven't looked into the update mechanism and how difficult it is to get always consistent updates.

The one-time fix in which errorbar() accounts for the current offset and direction is already a good improvement. It allows to create the correct graphs (with the right call order). If we can't get the consistent updates to work right now, I'd be willing to accept the on-time calculation and open a separate issue for the consistent update.

While it does contain the theta_offset and theta_direction and correctly adjusts theta, the issue I'm encountering is that it doesn’t retroactively apply to the error bars if ax.errorbar() is called before setting theta_zero_location or theta_direction.

The reason for this is that while transShift dynamically updates for other plot elements, it doesn’t retroactively change error bars unless ax.errorbar() is called again or the error bars are manually updated.

This is because you are transforming theta with transShift, but not attaching transShift to the marker in any way, so there is no way for it to update. The tricky thing here is that we need to transform a value and then use that value to set another transform. Almost all of our transforms just take in values and output transformed ones. The closest we have to what we need here is ScaledTranslation, which applies a transform on two values and then is a translational transform using the resulting values.

So in order to get the runtime changes, we'd have to copy ScaledTranslation into a ScaledRotation, which would apply transShift to theta, and then be a rotational transform from the results. This would then be the transform passed to the marker. However, I have not worked out exactly how this would work on polar plots, as the transform there is non-separable. It may not be straightforward to create a ScaledRotation that works generically but also in polar coordinate spaces.

@QuLogic thanks!

Following feedback, I wrote the OffsetRotation class in transforms.py based on ScaledTranslation. The class constructs a rotation matrix, which rotates the error bar caps according to the offset and direction values. And I updated _axes.py to use OffsetRotation for transforming the error bar caps.

The error bars now update correctly when ax.set_theta_zero_location and/or ax.set_theta_direction are called after ax.errorbar.

I would appreciate any help or suggestions on passing the CI/CD tests and ensuring the code is optimal. Thanks in advance!

@QuLogic I renamed OffsetRotation to ScaledRotation as described in your comments earlier. I’m sorry for any confusion this may have caused. The fix for the dynamic update of the error bar caps were based on your suggestions. Thanks for your understanding!

Also, I wanted to apologize for any confusion caused by my messy commit history. I recent merged main into the PR branch instead of rebasing the PR branch on top of main. This has made it more difficult to squash my commits cleanly, and I realize that it's caused unnecessary complexity in the commit history. I'm working on cleaning it up, and I appreciate your patience while I get things sorted. Moving forward, I’ll be sure to rebase to avoid this issue.

Hi, I wanted to let you know that while attempting to squash my own commits, I accidentally introduced a bunch of commits that are not my own into the PR. Unfortunately, I haven't been able to return to the previous state before the squash.

To keep things clean and avoid further complications, I’m going to create a new branch and open a new PR. I’ll move over my changes and ensure that the commit history is correct in the new PR. Sorry for the confusion and thanks for your patience!