Pitão:Incorporar Chaco no mistério do PyQt4
Pergunta
Como faço para adicionar o Chaco a um aplicativo PyQt4 existente?
Horas de pesquisas renderam pouco (procure por si mesmo).Até agora, percebi que preciso das seguintes linhas:
import os
os.environ['ETS_TOOLKIT']='qt4'
não consegui encontrar o código PyQt4-Chaco em nenhum lugar da internet
eu ficaria muito grato a qualquer pessoa que preenchesse os espaços em branco para me mostrar o gráfico de linha mais simples possível (com 2 pontos)
from PyQt4 import QtCore, QtGui
import sys
import os
os.environ['ETS_TOOLKIT']='qt4'
from enthought <blanks>
:
:
app = QtGui.QApplication(sys.argv)
main_window = QtGui.QMainWindow()
main_window.setCentralWidget(<blanks>)
main_window.show()
app.exec_()
print('bye')
qual classe Chaco/Enthought herda de QWidget?
Solução
Aqui está o que você precisa:
import os, sys
os.environ['ETS_TOOLKIT'] = 'qt4'
from PyQt4 import QtGui
app = QtGui.QApplication(sys.argv)
from numpy import linspace, pi, sin
from enthought.enable.api import Component, Container, Window
from enthought.chaco.api import create_line_plot, \
add_default_axes, \
add_default_grids, \
OverlayPlotContainer
x = linspace(-pi,pi,100)
y = sin(x)
plot = create_line_plot((x,y))
add_default_grids(plot)
add_default_axes(plot)
container = OverlayPlotContainer(padding = 50)
container.add(plot)
plot_window = Window(None, -1, component=container)
plot_window.control.setWindowTitle('hello')
plot_window.control.resize(400,400)
plot_window.control.show()
app.exec_()
plot_window.control herda de QWidget
Outras dicas
Acabei de ver isso hoje. É absolutamente possível e bastante direto incorporar Chaco dentro do QT, bem como WX. De fato, todos os exemplos, quando executados com o seu ambiente ETS_TOOLKIT VAR Set como "Qt4", estão fazendo exatamente isso. (Chaco requer Haver um kit de ferramentas da GUI subjacente.)
Escrevi um exemplo pequeno e independente que preencha os espaços em branco no seu modelo de código e demonstra como incorporar um gráfico de chaco dentro de uma janela QT.
"""
Example of how to directly embed Chaco into Qt widgets.
The actual plot being created is drawn from the basic/line_plot1.py code.
"""
import sys
from numpy import linspace
from scipy.special import jn
from PyQt4 import QtGui, QtCore
from enthought.etsconfig.etsconfig import ETSConfig
ETSConfig.toolkit = "qt4"
from enthought.enable.api import Window
from enthought.chaco.api import ArrayPlotData, Plot
from enthought.chaco.tools.api import PanTool, ZoomTool
class PlotFrame(QtGui.QWidget):
""" This widget simply hosts an opaque enthought.enable.qt4_backend.Window
object, which provides the bridge between Enable/Chaco and the underlying
UI toolkit (qt4). This code is basically a duplicate of what's in
enthought.enable.example_support.DemoFrame, but is reproduced here to
make this example more stand-alone.
"""
def __init__(self, parent, **kw):
QtGui.QWidget.__init__(self)
def create_chaco_plot(parent):
x = linspace(-2.0, 10.0, 100)
pd = ArrayPlotData(index = x)
for i in range(5):
pd.set_data("y" + str(i), jn(i,x))
# Create some line plots of some of the data
plot = Plot(pd, title="Line Plot", padding=50, border_visible=True)
plot.legend.visible = True
plot.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red")
plot.plot(("index", "y3"), name="j_3", color="blue")
# Attach some tools to the plot
plot.tools.append(PanTool(plot))
zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
plot.overlays.append(zoom)
# This Window object bridges the Enable and Qt4 worlds, and handles events
# and drawing. We can create whatever hierarchy of nested containers we
# want, as long as the top-level item gets set as the .component attribute
# of a Window.
return Window(parent, -1, component = plot)
def main():
app = QtGui.QApplication(sys.argv)
main_window = QtGui.QMainWindow(size=QtCore.QSize(500,500))
enable_window = create_chaco_plot(main_window)
# The .control attribute references a QWidget that gives Chaco events
# and that Chaco paints into.
main_window.setCentralWidget(enable_window.control)
main_window.show()
app.exec_()
if __name__ == "__main__":
main()
Não sei sobre o Chaco, mas estou usando VTK, aqui está o código para desenhar algumas linhas, tendo as coordenadas (x,y,z) delas.
"""Define an actor and its properties, to be drawn on the scene using 'lines' representation."""
ren = vtk.vtkRenderer()
apd=vtk.vtkAppendPolyData()
for i in xrange(len(coordinates)):
line=vtk.vtkLineSource()
line.SetPoint1(coordinates[i][0]) # 1st atom coordinates for a given bond
line.SetPoint2(coordinates[i][1]) # 2nd atom coordinates for a given bond
line.SetResolution(21)
apd.AddInput(line.GetOutput())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(apd.GetOutput())
lines_actor = vtk.vtkActor()
lines_actor.SetMapper(mapper)
lines_actor.GetProperty().SetColor(colorR, colorG, colorB)
lines_actor.GetProperty().SetOpacity(opacity)
# Add newly created actor to the renderer.
self.ren.AddViewProp(actor) # Prop is the superclass of all actors, composite props etc.
# Update renderer.
self.ren.GetRenderWindow().Render()
Ele usa QVTKRenderWindowInteractor para interagir com o PyQT4.
Não conheço Chaco, mas um olhar rápido me diz que isso não é possível.
Chaco e PYQT são kits de ferramentas gráficos projetados para interagir com o usuário. O Chaco é orientado para o enredo e o PYQT mais orientado para o aplicativo. Cada um tem sua própria maneira de gerenciar o que é uma janela, como detectar cliques no usuário, como lidar com eventos de pintura, ... para que eles não se misturem.
Se você precisar plotar o software, tente usar o MatPlotlib para gerar imagens estáticas do gráfico e mostrar a imagem no PYQT. Ou tente um gráfico baseado em PYQ ou plotagem de ferramentas.