Python: Insertar en Chaco PyQt4 misterio

Question

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

Las horas de búsquedas produjo poco ( buscar por sí mismo ). 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

i sería muy agradecidos a cualquiera llenado los espacios en blanco para mostrarme la trama de línea 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')

lo que hereda de la clase Chaco / Enthought 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_()

hereda plot_window.control de QWidget

Answer 2

acabo de ver esto hoy. Es absolutamente posible y bastante sencillo de Chaco incrustar dentro de Qt, así como WX. De hecho, todos los ejemplos, cuando se ejecuta con su entorno ETS_TOOLKIT var conjunto de "Qt4", están haciendo exactamente esto. (Chaco requiere que exista un conjunto de herramientas GUI subyacente.)

He escrito un pequeño ejemplo independiente que llena los espacios en blanco de la 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()

Answer 3

No sé acerca de Chaco, pero estoy usando VTK, aquí está el código para dibujar algunas líneas, tener un (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

No sé Chaco, pero un vistazo rápido me dice que esto no es posible.

Tanto Chaco y PyQt son conjuntos de herramientas gráficas diseñados para interactuar con el usuario. Chaco es orientado trama y orientado PyQt más aplicación. Cada uno tiene su propia manera de manejar lo que es una ventana, la forma de detectar el usuario hace clic, cómo manejar los eventos de pintura, ... para que no se mezclen entre sí.

Si es necesario que el trazado de software, puede tratar de utilizar matplotlib para generar imágenes estáticas del gráfico y mostrar la imagen en PyQt. O probar un gráfico basado PyQt o kit de herramientas de trazado.