[Bug Windows] Colorbar not appear during animation when changing colormap

[Goczilla]

Bug report

Bug summary

I created a subplot in a figure for displaying an image with imshow, and I add a colorbar. With no animation, I can change the colormap changing the value of the ComboBox and the colorbar is updated correctly.

But if I add an animation, the colorbar disappear each time I change the colormap. I have to click on another window (other software, etc) or resize the GUI to see the colorbar again.

This problem seems to be only on Windows (someone test my code on Linux and no bug)

Code for reproduction

Sorry for the size of the example :

import sys
    from PyQt5.QtGui import *
    from PyQt5.QtWidgets import *
    from PyQt5.QtCore import *
    
    import matplotlib
    matplotlib.use('Qt5Agg')
    from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
    import matplotlib.pyplot as plt
    from mpl_toolkits.axes_grid1 import make_axes_locatable
    from matplotlib import animation
    
    class FenetrePrincipale(QWidget):
        def __init__(self, parent=None):
            super(FenetrePrincipale, self).__init__(parent)
            self.setupUi(self)
    
        # Fonction de configuration de la classe
        def setupUi(self, Form):
            self.Form = Form
    
            Form.setMinimumSize(1220, 850)
    
            self.creation_GUI()
            self.creation_figure()
            self.creation_layout()
    
            self.tabWidget.setCurrentIndex(0)
            self.Bouton_quitter.clicked.connect(self.close)
            self.anim = animation.FuncAnimation(self.figure, self.animate, interval=10, blit=True)
            self.Widget_choixPalette_ComboBox.currentIndexChanged.connect(self.changementPalette)

        def changementPalette(self, onglet):
            self.image.set_cmap('binary')
            self.canvas.draw()
    
        def animate(self, i):
            # a = self.thread_1.img
            self.image.set_array(self.imageInit)
            return [self.image]
    
        def resizeEvent(self, QResizeEvent):
            self.tabWidget.setMinimumSize(QSize(self.width() - 20, self.height() - 60))
    
        def creation_GUI(self):
            self.tabWidget = QTabWidget()
            self.tab1 = QWidget()
            self.tabWidget.addTab(self.tab1, "  Tab1  ")
    
            self.Widget_choixPalette_Label = QLabel(self.tab1)
            self.Widget_choixPalette_Label.setText("Text1")
            self.Widget_choixPalette_ComboBox = QComboBox(self.tab1)
            self.Widget_choixPalette_ComboBox.addItem("Try1")
            self.Widget_choixPalette_ComboBox.addItem("Try2")
    
            self.Bouton_quitter = QPushButton(self.tab1)
            self.Bouton_quitter.setText("Quit")
    
        def creation_layout(self):
            LayoutForm = QGridLayout(self)
            LayoutForm.addWidget(self.tabWidget, 0, 0, 1, 1)
    
            LayoutTab1 = QGridLayout(self.tab1)
    
            LayoutTab1.addWidget(self.Widget_choixPalette_Label, 0, 1, 1, 1)
            LayoutTab1.addWidget(self.Widget_choixPalette_ComboBox, 1, 1, 1, 1)
            self.Widget_choixPalette_ComboBox.setMinimumWidth(200)
    
            LayoutTab1.addWidget(self.canvas, 2, 0, 1, 3)
            LayoutTab1.addWidget(self.Bouton_quitter, 2, 3, 1, 1, Qt.AlignRight | Qt.AlignBottom)
    
            LayoutTab1.setRowStretch(2, 1)
            LayoutTab1.setColumnStretch(0, 1)
            LayoutTab1.setColumnStretch(2, 1)
    
        def creation_figure(self):
            # Create figure (transparent background)
            self.figure = plt.figure()
            # self.figure.patch.set_facecolor('None')
            self.canvas = FigureCanvas(self.figure)
            self.canvas.setStyleSheet("background-color:transparent;")
    
            # Adding one subplot for image
            self.axe0 = self.figure.add_subplot(111)
            self.axe0.get_xaxis().set_visible(False)
            self.axe0.get_yaxis().set_visible(False)
    
            # Data for init image
            self.imageInit = [[255] * 320 for i in range(240)]
            self.imageInit[0][0] = 0
    
            # Init image and add colorbar
            self.image = self.axe0.imshow(self.imageInit, interpolation='none')
            divider = make_axes_locatable(self.axe0)
            cax = divider.new_vertical(size="5%", pad=0.05, pack_start=True)
            self.colorbar = self.figure.add_axes(cax)
            self.figure.colorbar(self.image, cax=cax, orientation='horizontal')
    
            plt.subplots_adjust(left=0, bottom=0.05, right=1, top=1, wspace=0, hspace=0)
    
            self.canvas.draw()
    
    if __name__ == '__main__':
        app = QApplication(sys.argv)
        # QApplication.setStyle(QStyleFactory.create("plastique"))
        form = FenetrePrincipale()
        form.show()
        sys.exit(app.exec_())

Actual outcome

The colorbar is not visible when changing colormap during animation

Expected outcome

See my colorbar at any time.

Matplotlib version

• Operating system: Windows 7 Pro
• Matplotlib version: 2.1.0
• Matplotlib backend: Qt5Agg
• Python version: 3.6

[tacaswell]

This is likely something going wrong with the blitting....

Very odd that it is windows only though.

On a very long shot, does it work if you change draw to daw_idle() in changementPalette?

[Goczilla]

Hello,

draw_idle doesn't correct the problem.

[ImportanceOfBeingErnest]

I can reproduce the behaviour with matplotlib 2.1, python 2.7 on windows 8 using pyqt4.

Using draw_idle will help "a bit", i.e. it would often but not always update the colorbar. I suspect that this might be due to the timing between the redraw and the next animation step happening.

A workaround, as also given as answer to the respective Stackoverflow question would be to pause the animation, update the necessary bits, then continue the animation.

def changementPalette(self, onglet):
    self.anim.event_source.stop()
    if onglet==0:
        self.image.set_cmap('viridis')
    else:
        self.image.set_cmap('binary')
    self.canvas.draw_idle()
    self.anim.event_source.start()

[Goczilla]

Set the blit argument to False works, but does it mean each time the animation refresh the image, each elements of the figure is updated ? Because I refresh an 320*256 pixels image at around 40 fps (with imshow and cubic interpolation) and this for hours. So it could be dangerous I think for the CPU ressources that matplotlib needs no? For information, my images come from a camera and a stop/start isn't visible with our eyes. So the two solutions are okay, I just need some information about blitting if possible please.

[tacaswell]

http://matplotlib.org/api/animation_api.html#funcanimation is the best documentation of blitting in the docs. Joe Kington's answers on SO are also extremely good.

There is some race condition in here with the updates, changing the color map, re-drawing the whole figure, and a new background image being grabbed by the animation.

It might be easier to not use FunctionAnimation and do the blitting your self. You will have to watch for resize and draw events to update the background, but I think it would make your code easier to understand / maintain, let you update on push from the camera (rather than on the animation poll loop), and you gets you out of the above race conditions.

[Goczilla]

I understand it will be better to control myself all aspect of the refresh. But I get images at 60 fps and I am using an animation exactly to go as fast as possible that matplotlib permits ^.^. When I will have the time, I will improve my knowledge about blitting, etc to do something better. I am still discovering Python and matplotlib so there is a lot of information to understand and apply to my project ;)

[Goczilla]

The solution with stop/start animation works when I change colormap, but when I change other element of my GUI (for example, the text in a QTextEdit), sometimes the colorbar disappears again. It is fun ^.^
And if I set the blit argument of the animation to False , there is no bug. I will stay with no blitting for now because I have no time to do the blitting myself.

If I have more information about this bug, I will report it in this post.

[dopplershift]

I'm working on some updates to the blitting code for 2.2. I'll see if I can reproduce and make sure the new code is more robust for this use case.

[github-actions]

This issue has been marked "inactive" because it has been 365 days since the last comment. If this issue is still present in recent Matplotlib releases, or the feature request is still wanted, please leave a comment and this label will be removed. If there are no updates in another 30 days, this issue will be automatically closed, but you are free to re-open or create a new issue if needed. We value issue reports, and this procedure is meant to help us resurface and prioritize issues that have not been addressed yet, not make them disappear. Thanks for your help!