Python: Incruste Chaco en PyQt4 Mystery

Question

¿Cómo hago para agregar Chaco a una aplicación PyQt4 existente?

Horas de búsquedas cedidas poco (search for yourself). Hasta ahora me he dado cuenta que necesito las siguientes líneas:

import os 
os.environ['ETS_TOOLKIT']='qt4' 

no pude encontrar el código PyQt4-Chaco en cualquier lugar en los Internet

yo estaría muy agradecidos a cualquiera de llenar los espacios en blanco para mí el espectáculo diagrama de línea más simple posible (con 2 puntos)

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') 

¿Qué clase de Chaco/Enthought hereda de QWidget?

Answer 1

aquí es lo que necesita:

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 hereda de QWidget

Answer 2

No sé Chaco, pero una mirada rápida me dice que esto no es posible.

Tanto Chaco como PyQt son juegos de herramientas gráficas diseñadas para interactuar con el usuario. Chaco está orientado a la trama y PyQt más orientado a aplicaciones. Cada uno tiene su propia forma de administrar qué es una ventana, cómo detectar los clics de los usuarios, cómo manejar los eventos de pintura, ... para que no se mezclen.

Si necesita trazar el software, puede intentar usar matplotlib para generar imágenes estáticas de gráfico y mostrar la imagen en PyQt. O pruebe un gráfico basado en PyQt o un juego de herramientas de trazado.

Answer 3

No sé de Chaco, pero estoy usando VTK, aquí hay un código para dibujar algunas líneas, que tienen una (x, y, z) las coordenadas de ellos.

"""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() 

Utiliza QVTKRenderWindowInteractor para interactuar con el PyQT4.

Answer 4

acabo de ver esto hoy. Es absolutamente posible y bastante sencillo insertar Chaco dentro de Qt y WX. De hecho, todos los ejemplos, cuando se ejecutan con su entorno var ETS_TOOLKIT establecido en "qt4", están haciendo exactamente esto. (Chaco requiere que haya un conjunto de herramientas GUI subyacente.)

He escrito un pequeño ejemplo, independiente que llena los espacios en blanco en su plantilla de código, y demuestra cómo incrustar un gráfico chaco dentro de una ventana de Qt.

qt_example.py:

""" 
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()