def __init__(self, parent=None, width=6, height=4, dpi=100,x=0,y=0,pxlbl="",pylbl="",point = False,adjust=False):
self.fig = Figure(figsize=(width, height), dpi=dpi,)
FigureCanvas.__init__(self,self.fig)
self.setPlot(x,y,pxlbl,pylbl,adjust=adjust)
def __init__(self, parent_conn, process_events, figure):
FigureCanvasAgg.__init__(self, figure)
self.parent_conn = parent_conn
self.process_events = process_events
self.buffer_lock = threading.Lock()
self.buffer = None
self.buffer_width = None
self.buffer_height = None
self.blit_lock = threading.Lock()
self.blit_buffer = None
self.blit_width = None
self.blit_height = None
self.blit_top = None
self.blit_left = None
self.update_remote = threading.Event()
t = threading.Thread(target=self.listen_for_remote,
name="canvas listen",
args=())
t.daemon = True
t.start()
t = threading.Thread(target=self.send_to_remote,
name="canvas send",
args=())
t.daemon = True
t.start()
def __init__(self):
self.fig = Figure()
self.ax = self.fig.add_subplot(111)
self.ax.set_xlim(0, 10)
self.ax.set_ylim(0,10)
self.ax.set_autoscale_on(False)
FigureCanvasAgg.__init__(self, self.fig)
self.background = self.copy_from_bbox(self.ax.bbox)
def __init__( self, figure ):
if DEBUG: print 'FigureCanvasQtAgg: ', figure
FigureCanvasQT.__init__( self, figure )
FigureCanvasAgg.__init__( self, figure )
self.drawRect = False
self.rect = []
self.replot = True
self.pixmap = qt.QPixmap()
def __init__( self, figure, parent=None):
if DEBUG: print 'FigureCanvasQtAgg: ', figure
FigureCanvasQT.__init__(self, figure, parent)
FigureCanvasAgg.__init__( self, figure )
self.drawRect = False
self.rect = []
self.replot = True
self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent)
def __init__( self, figure ):
if DEBUG: print 'FigureCanvasQtAgg: ', figure
FigureCanvasQT.__init__( self, figure )
FigureCanvasAgg.__init__( self, figure )
self.drawRect = False
self.rectangle = []
self.blitbox = None
self.replot = True
self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent)
def __init__(self, size = (7,3.5),
logx = False,
logy = False,
legends = True,
bw = False):
self.fig = Figure(figsize=size) #in inches
FigureCanvas.__init__(self, self.fig)
self._logX = logx
self._logY = logy
self._bw = bw
self._legend = legends
self._legendList = []
self._dataCounter = 0
if not legends:
if self._logY:
ax = self.fig.add_axes([.15, .15, .75, .8])
else:
ax = self.fig.add_axes([.15, .15, .75, .75])
else:
if self._logY:
ax = self.fig.add_axes([.15, .15, .7, .8])
else:
ax = self.fig.add_axes([.15, .15, .7, .8])
ax.set_axisbelow(True)
self.ax = ax
if self._logY:
self._axFunction = ax.semilogy
else:
self._axFunction = ax.plot
if self._bw:
self.colorList = ['k'] #only black
self.styleList = ['-', ':', '-.', '--']
self.nColors = 1
else:
self.colorList = colorlist
self.styleList = ['-', '-.', ':']
self.nColors = len(colorlist)
self.nStyles = len(self.styleList)
self.colorIndex = 0
self.styleIndex = 0
self.xmin = None
self.xmax = None
self.ymin = None
self.ymax = None
self.limitsSet = False
def __init__(self, couleur_fond='w', dimensions=None, feuille=None):
self.figure = Figure(dpi=param.dpi_ecran,
frameon=True,
facecolor=couleur_fond)
FigureCanvasAgg.__init__(self, self.figure)
self.axes = self.figure.add_axes([0, 0, 1, 1], frameon=False)
self._dimensions = dimensions
self.__feuille_actuelle = feuille
self.axes.set_xticks([])
self.axes.set_yticks([])
# Ces paramètres ne sont utiles que pour les sur-classes s'intégrant dans un GUI.
self.editeur = None
self.select = None # objet couramment sélectionné
#if self.param("transformation_affine") is not None:
# self.transformation = matplotlib.transforms.Affine(*self.param("transformation_affine"))
# self.figure.set_transform(self.transformation)
# self.axes.set_transform(self.transformation)
#else:
# self.transformation = None
if self.param("transformation") is not None:
a, b, c, d = self.param("transformation")
# CODE À RÉÉCRIRE et À ADAPTER
self.transformation = numpy.matrix([[a, b], [c, d]])
else:
self.transformation = None
self._affichage_gele = False
# Ne pas utiliser directement.
# Si on met la valeur a True, self.rafraichir_affichage() ne fait plus rien.
# Cela permet d'effectuer un certain nombre d'actions rapidement,
# et de n'actualiser qu'à la fin.
# En particulier, cela sert pour charger une figure depuis un fichier .geo
self._affichage_gele_en_apparence = False
# Ne pas utiliser directement.
# Si on met la valeur a True, self.rafraichir_affichage() fonctionne toujours,
# mais les changements ne s'affichent pas à l'écran.
# Cela permet d'effectuer un certain nombre d'actions sans que l'utilisateur s'en apercoive
# (pas de clignotement de l'affichage).
# Par contre, le gain de temps est négligeable par rapport à un vrai gel de l'affichage.
# En particulier, cela sert pour exporter une figure.
self.graph = Moteur_graphique(self)
self.parametres = [
u"taille", u"gradu", u"afficher_axes", u"afficher_quadrillage",
u"afficher_fleches", u"repere", u"resolution", u"origine_axes",
u"utiliser_repere", u"quadrillages", u"couleur_papier_millimetre",
u"liste_axes", u"orthonorme", u"grille_aimantee", u"zoom_texte",
"zoom_ligne"
]
self.liste_objets_en_gras = WeakList()
self.initialiser()
def __init__(self, figure):
FigureCanvasAgg.__init__(self, figure)
self.__ref_id, self.__ref = javabridge.create_jref(self)
self.__cpython = javabridge.make_instance(
'org/cellprofiler/javabridge/CPython', '()V')
paint_script = (
'import javabridge\n'
'self = javabridge.redeem_jref("%s")\n'
'self.draw(javabridge.JWrapper(graphics))\n') % self.__ref_id
component = javabridge.run_script(
"""
new javax.swing.JComponent() {
paintComponent: function(graphics) {
locals = new java.util.Hashtable();
locals.put("graphics", graphics);
cpython.exec(script, locals, locals);
}
}
""", dict(cpython=self.__cpython, script=paint_script))
self.__component = javabridge.JWrapper(component)
self.__event_queue_class = None
self.__component_listener = javabridge.JProxy(
'java.awt.event.ComponentListener',
dict(componentHidden=self._on_component_hidden,
componentMoved=self._on_component_moved,
componentResized=self._on_component_resized,
componentShown=self._on_component_shown))
self.__component.addComponentListener(self.__component_listener.o)
self.__key_event_cls = javabridge.JClassWrapper(
'java.awt.event.KeyEvent')
self.__key_listener = javabridge.JProxy(
'java.awt.event.KeyListener',
dict(keyPressed=self._on_key_pressed,
keyReleased=self._on_key_released,
keyTyped=self._on_key_typed))
self.__component.addKeyListener(self.__key_listener.o)
self.__component.setFocusable(True)
self.__mouse_listener = javabridge.JProxy(
'java.awt.event.MouseListener',
dict(mouseClicked=self._on_mouse_clicked,
mouseEntered=self._on_mouse_entered,
mouseExited=self._on_mouse_exited,
mousePressed=self._on_mouse_pressed,
mouseReleased=self._on_mouse_released))
self.__component.addMouseListener(self.__mouse_listener.o)
self.__mouse_motion_listener = javabridge.JProxy(
'java.awt.event.MouseMotionListener',
dict(mouseDragged=self._on_mouse_dragged,
mouseMoved=self._on_mouse_moved))
self.__component.addMouseMotionListener(self.__mouse_motion_listener.o)
def __init__(self, figure):
QtGui.QWidget.__init__(self)
FigureCanvasAgg.__init__(self, figure)
self.figure = figure
self.setMouseTracking(True)
w,h = self.get_width_height()
self.resize( w, h )
self.drawRect = False
self.rect = []
self.replot = True
self.pixmap = QtGui.QPixmap()
def __init__( self, figure ):
if DEBUG: print 'FigureCanvasQtAgg: ', figure
FigureCanvasQT.__init__( self, figure )
FigureCanvasAgg.__init__( self, figure )
self.drawRect = False
self.rect = []
self.blitbox = None
self.replot = True
# JB: do NOT set QtCore.Qt.WA_OpaquePaintEvent because part of the figure is transparent.
#self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent)
# JB: added "animating" flag.
self.animating = False
def __init__(self, couleur_fond = 'w', dimensions = None, feuille = None):
self.figure = Figure(dpi = param.dpi_ecran, frameon=True, facecolor = couleur_fond)
FigureCanvasAgg.__init__(self, self.figure)
self.axes = self.figure.add_axes([0, 0, 1, 1], frameon=False)
self._dimensions = dimensions
self.__feuille_actuelle = feuille
self.axes.set_xticks([])
self.axes.set_yticks([])
# Ces paramètres ne sont utiles que pour les sur-classes s'intégrant dans un GUI.
self.editeur = None
self.select = None # objet couramment sélectionné
#if self.param("transformation_affine") is not None:
# self.transformation = matplotlib.transforms.Affine(*self.param("transformation_affine"))
# self.figure.set_transform(self.transformation)
# self.axes.set_transform(self.transformation)
#else:
# self.transformation = None
if self.param("transformation") is not None:
a, b, c, d = self.param("transformation")
# CODE À RÉÉCRIRE et À ADAPTER
self.transformation = numpy.matrix([[a, b], [c, d]])
else:
self.transformation = None
self._affichage_gele = False
# Ne pas utiliser directement.
# Si on met la valeur a True, self.rafraichir_affichage() ne fait plus rien.
# Cela permet d'effectuer un certain nombre d'actions rapidement,
# et de n'actualiser qu'à la fin.
# En particulier, cela sert pour charger une figure depuis un fichier .geo
self._affichage_gele_en_apparence = False
# Ne pas utiliser directement.
# Si on met la valeur a True, self.rafraichir_affichage() fonctionne toujours,
# mais les changements ne s'affichent pas à l'écran.
# Cela permet d'effectuer un certain nombre d'actions sans que l'utilisateur s'en apercoive
# (pas de clignotement de l'affichage).
# Par contre, le gain de temps est négligeable par rapport à un vrai gel de l'affichage.
# En particulier, cela sert pour exporter une figure.
self.graph = Moteur_graphique(self)
self.parametres = ["taille", "gradu", "afficher_axes", "afficher_quadrillage",
"afficher_fleches", "repere", "resolution", "origine_axes",
"utiliser_repere", "quadrillages", "couleur_papier_millimetre",
"liste_axes", "ratio", "grille_aimantee", "zoom_texte",
"zoom_ligne", "dpi_ecran"]
self.objets_en_gras = WeakSet()
self.initialiser()
def __init__(self, figure, master=None, resize_callback=None):
FigureCanvasAgg.__init__(self, figure)
self._idle = True
self._idle_callback = None
t1, t2, w, h = self.figure.bbox.bounds
w, h = int(w), int(h)
self._tkcanvas = Tk.Canvas(master=master,
background="white",
width=w,
height=h,
borderwidth=0,
highlightthickness=0)
self._tkphoto = Tk.PhotoImage(master=self._tkcanvas, width=w, height=h)
self._tkcanvas.create_image(w // 2, h // 2, image=self._tkphoto)
self._resize_callback = resize_callback
self._tkcanvas.bind("<Configure>", self.resize)
self._tkcanvas.bind("<Key>", self.key_press)
self._tkcanvas.bind("<Motion>", self.motion_notify_event)
self._tkcanvas.bind("<KeyRelease>", self.key_release)
for name in "<Button-1>", "<Button-2>", "<Button-3>":
self._tkcanvas.bind(name, self.button_press_event)
for name in "<Double-Button-1>", "<Double-Button-2>", "<Double-Button-3>":
self._tkcanvas.bind(name, self.button_dblclick_event)
for name in "<ButtonRelease-1>", "<ButtonRelease-2>", "<ButtonRelease-3>":
self._tkcanvas.bind(name, self.button_release_event)
# Mouse wheel on Linux generates button 4/5 events
for name in "<Button-4>", "<Button-5>":
self._tkcanvas.bind(name, self.scroll_event)
# Mouse wheel for windows goes to the window with the focus.
# Since the canvas won't usually have the focus, bind the
# event to the window containing the canvas instead.
# See http://wiki.tcl.tk/3893 (mousewheel) for details
root = self._tkcanvas.winfo_toplevel()
root.bind("<MouseWheel>", self.scroll_event_windows, "+")
# Can't get destroy events by binding to _tkcanvas. Therefore, bind
# to the window and filter.
def filter_destroy(evt):
if evt.widget is self._tkcanvas:
self._master.update_idletasks()
self.close_event()
root.bind("<Destroy>", filter_destroy, "+")
self._master = master
self._tkcanvas.focus_set()
def __init__(self, figure, master=None, resize_callback=None):
FigureCanvasAgg.__init__(self, figure)
self._idle = True
self._idle_callback = None
t1, t2, w, h = self.figure.bbox.bounds
w, h = int(w), int(h)
self._tkcanvas = Tk.Canvas(
master=master,
width=w,
height=h,
borderwidth=0,
highlightthickness=0)
self._tkphoto = Tk.PhotoImage(master=self._tkcanvas, width=w, height=h)
self._tkcanvas.create_image(w // 2, h // 2, image=self._tkphoto)
self._resize_callback = resize_callback
self._tkcanvas.bind("<Configure>", self.resize)
self._tkcanvas.bind("<Key>", self.key_press)
self._tkcanvas.bind("<Motion>", self.motion_notify_event)
self._tkcanvas.bind("<KeyRelease>", self.key_release)
for name in "<Button-1>", "<Button-2>", "<Button-3>":
self._tkcanvas.bind(name, self.button_press_event)
for name in "<Double-Button-1>", "<Double-Button-2>", "<Double-Button-3>":
self._tkcanvas.bind(name, self.button_dblclick_event)
for name in "<ButtonRelease-1>", "<ButtonRelease-2>", "<ButtonRelease-3>":
self._tkcanvas.bind(name, self.button_release_event)
# Mouse wheel on Linux generates button 4/5 events
for name in "<Button-4>", "<Button-5>":
self._tkcanvas.bind(name, self.scroll_event)
# Mouse wheel for windows goes to the window with the focus.
# Since the canvas won't usually have the focus, bind the
# event to the window containing the canvas instead.
# See http://wiki.tcl.tk/3893 (mousewheel) for details
root = self._tkcanvas.winfo_toplevel()
root.bind("<MouseWheel>", self.scroll_event_windows, "+")
# Can't get destroy events by binding to _tkcanvas. Therefore, bind
# to the window and filter.
def filter_destroy(evt):
if evt.widget is self._tkcanvas:
self.close_event()
root.bind("<Destroy>", filter_destroy, "+")
self._master = master
self._tkcanvas.focus_set()
def __init__(self, preferences, parent=None):
self.preferences = preferences
self.fig = Figure(facecolor='white', dpi=96)
FigureCanvas.__init__(self, self.fig)
#self.setParent(parent)
#FigureCanvas.setSizePolicy(self,QtGui.QSizePolicy.Fixed,QtGui.QSizePolicy.Fixed)
#FigureCanvas.updateGeometry(self)
self.cid = None
self.type = '<none>'
self.name = '<none>'
self.bSupportsHighlight = False
self.bPlotFeaturesIndividually = True
def __init__(self, figure, parent=None, coordinates=True):
if DEBUG:
print('FigureCanvasQtQuickAgg qtquick5: ', figure)
# _create_qApp()
if figure is None:
figure = Figure((6.0, 4.0))
QtQuick.QQuickPaintedItem.__init__(self, parent=parent)
FigureCanvasAgg.__init__(self, figure=figure)
self._drawRect = None
self.blitbox = None
# Activate hover events and mouse press events
self.setAcceptHoverEvents(True)
self.setAcceptedMouseButtons(QtCore.Qt.AllButtons)
self._agg_draw_pending = False
def __init__(self, options):
"""Initialization."""
if options:
self.options = options
else:
Options = namedtuple('Options', 'width height font_size dpi')
self.options = Options(6, 6, 10, 300)
self.set_font_size(self.options.font_size)
self.fig = Figure(facecolor='white', dpi=self.options.dpi)
FigureCanvas.__init__(self, self.fig)
self.cid = None
self.type = '<none>'
self.name = '<none>'
self.axes_colour = (0.5, 0.5, 0.5)
def __init__(self, options):
self.options = options
# Global plot settings
mpl.rcParams['font.size'] = self.options.font_size
mpl.rcParams['axes.titlesize'] = self.options.font_size
mpl.rcParams['axes.labelsize'] = self.options.font_size
mpl.rcParams['xtick.labelsize'] = self.options.font_size
mpl.rcParams['ytick.labelsize'] = self.options.font_size
mpl.rcParams['legend.fontsize'] = self.options.font_size
mpl.rcParams['svg.fonttype'] = 'none'
self.fig = Figure(facecolor='white', dpi=options.dpi)
FigureCanvas.__init__(self, self.fig)
self.cid = None
self.type = '<none>'
self.name = '<none>'
self.axesColour = (0.5, 0.5, 0.5)
def __init__(self, options): self.options = options # Global plot settings mpl.rcParams['font.size'] = self.options.font_size mpl.rcParams['axes.titlesize'] = self.options.font_size mpl.rcParams['axes.labelsize'] = self.options.font_size mpl.rcParams['xtick.labelsize'] = self.options.font_size mpl.rcParams['ytick.labelsize'] = self.options.font_size mpl.rcParams['legend.fontsize'] = self.options.font_size mpl.rcParams['svg.fonttype'] = 'none' self.fig = Figure(facecolor='white', dpi=options.dpi) FigureCanvas.__init__(self, self.fig) self.cid = None self.type = '<none>' self.name = '<none>' self.axesColour = (0.5, 0.5, 0.5)
def __init__(self, figure):
if DEBUG:
print('FigureCanvasQtAgg: ', figure)
FigureCanvasQT.__init__(self, figure)
FigureCanvasAgg.__init__(self, figure)
self._drawRect = None
self.blitbox = None
self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent)
# it has been reported that Qt is semi-broken in a windows
# environment. If `self.draw()` uses `update` to trigger a
# system-level window repaint (as is explicitly advised in the
# Qt documentation) the figure responds very slowly to mouse
# input. The work around is to directly use `repaint`
# (against the advice of the Qt documentation). The
# difference between `update` and repaint is that `update`
# schedules a `repaint` for the next time the system is idle,
# where as `repaint` repaints the window immediately. The
# risk is if `self.draw` gets called with in another `repaint`
# method there will be an infinite recursion. Thus, we only
# expose windows users to this risk.
if sys.platform.startswith('win'):
self._priv_update = self.repaint
else:
self._priv_update = self.update
def __init__(self, options):
"""Initialization."""
if options:
self.options = options
else:
Options = namedtuple(
'Options', 'width height label_font_size tick_font_size dpi')
self.options = Options(6, 6, 10, 8, 300)
self.set_font_size(self.options.label_font_size,
self.options.tick_font_size)
self.fig = Figure(facecolor='white', dpi=self.options.dpi)
FigureCanvas.__init__(self, self.fig)
self.cid = None
self.type = '<none>'
self.name = '<none>'
self.axes_colour = (0.5, 0.5, 0.5)
self.logger = logging.getLogger('timestamp')
def __init__(self, parent, fixe = False):
"Si fixe = True, l'utilisateur ne peut pas zoomer ou recadrer la fenêtre d'affichage avec la souris."
self.parent = parent
# fenetre_principale>onglets>panel>canvas
self.fenetre_principale = self.parent.parent.parent
# initialisation dans cet ordre (self.figure doit être défini pour initialiser FigureCanvas)
Canvas.__init__(self, couleur_fond = self.param("couleur_fond"))
FigureCanvasQT.__init__(self, figure=self.figure)
# From matplotlib/backends/backend_qt5agg.py
# Calling FigureCanvasQTAggBase.__init__() directly results in a strange error.
self.setAttribute(Qt.WA_OpaquePaintEvent)
self._agg_draw_pending = False
self._bbox_queue = []
self._drawRect = None
FigureCanvasAgg.__init__(self, figure=self.figure)
##if param.plateforme == "Linux":
##self.SetSize(wx.Size(10, 10))
##elif param.plateforme == "Windows":
##self.SetWindowStyle(wx.WANTS_CHARS)
##self.Refresh()
# Message à afficher en dehors des affichages temporaires
self._message_remanent = ''
# Les modes définissent l'effet des évènements de la souris.
# Modes possibles:
# - 'defaut' (déplacer un objet),
# - 'zoom' (zoomer sur une zone),
# - 'select' (sélectionner une zone).
self.mode = "defaut"
# Action en cours :
# - None (aucune)
# - 'select' (sélection d'une zone pour export ou édition)
# - 'zoom' (sélection d'une zone pour zoomer)
# - 'shift' (translation du contenu de la fenêtre)
self.action_en_cours = None
# Rechercher les objets à proximité du pointeur
self.redetecter = True
# Objet devant être prochainement sélectionné (en cas de "litige" entre 2 objets)
self.select_memoire = None
# Étiquette couramment séléctionnée
self.etiquette_selectionnee = None
# Bloquer le zoom possible
self.fixe = fixe
# Fonction à lancer au prochain clic de souris (au lieu des actions par défaut)
self.interaction = None
# Fonction à lancer au prochain déplacement de souris (au lieu des actions par défaut)
self.interaction_deplacement = None
# Autoriser les objets à être éditer par un clic droit.
self.edition_par_clic_droit = True
# Édite les noms et étiquettes des points, textes, etc.
self.editeur = MiniEditeur(self)
# Paramètres temporaires d'affichage
self._dessin_temporaire = False
# Liste ordonnée (pour la détection) des objets de la feuille actuelle.
self.sel = []
self.motion_event = None
self.wheel_event_count = 0
self.wheel_ctrl_event_count = 0
##self.Bind(wx.EVT_MOUSEWHEEL, self.EventOnWheel)
##self.Bind(wx.EVT_MOTION, self.EventOnMotion)
##self.Bind(wx.EVT_IDLE, self.OnIdle)
self._timer = QTimer(self)
self._timer.timeout.connect(self._actualiser_si_necessaire)
self._timer.setInterval(100)
self.setFocusPolicy(Qt.StrongFocus)
self.setMouseTracking(True)
def __init__(self, figure):
FigureCanvasAgg.__init__(self, figure)
def __init__(self, figure):
FigureCanvasAgg.__init__(self, figure)
ItermplotCanvasMixin.__init__(self)
def __init__(self, figure):
FigureCanvasAgg.__init__(self, figure)
