Frage Python: Betten Sie Chaco in PyQt4 Mystery ein


Wie kann ich Chaco zu einer bestehenden PyQt4-Anwendung hinzufügen?

Stunden der Suche ergab wenig (suche nach dir selbst). Bisher habe ich gedacht, ich brauche die folgenden Zeilen:

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

Ich konnte den PyQt4-Chaco Code nirgendwo im Internet finden

Ich wäre jedem dankbar, der die Lücken füllt, um mir die einfachste mögliche Liniendarstellung zu zeigen (mit 2 Punkten)

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

Welche Chaco / Enthought-Klasse erbt von QWidget?


8
2018-01-27 15:47


Ursprung


Antworten:


Hier ist was du brauchst:

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 erbt von QWidget


7
2018-01-27 23:17



Ich habe das heute gesehen. Es ist absolut möglich und ziemlich einfach, Chaco sowohl in Qt als auch in WX einzubetten. Tatsächlich tun alle Beispiele, wenn sie mit Ihrer ETS_TOOLKIT-Umgebungsvariable auf "qt4" ausgeführt werden, genau das. (Chaco erfordert es gibt ein zugrunde liegendes GUI-Toolkit.)

Ich habe ein kleines, eigenständiges Beispiel geschrieben, das die Lücken in Ihrer Codevorlage ausfüllt und demonstriert, wie Sie ein Chaco-Plot in ein Qt-Fenster einbetten.

qt_beispiel.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()

8
2018-02-11 23:40



Ich weiß nicht über Chaco, aber ich verwende VTK, hier ist Code, um einige Linien zu zeichnen, mit einer (x, y, z) Koordinaten von ihnen.

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

Es verwendet QVTKRenderWindowInteractor, um mit dem PyQT4 zu interagieren.


0
2018-01-27 20:48



Ich kenne Chaco nicht, aber ein kurzer Blick sagt mir, dass das nicht möglich ist.

Sowohl Chaco als auch PyQt sind grafische Toolkits, die entworfen wurden, um mit dem Benutzer zu interagieren. Chaco ist plotorientiert und PyQt eher anwendungsorientiert. Jeder hat seine eigene Art zu verwalten, was ein Fenster ist, wie man Benutzerklicks erkennt, wie man mit Paint-Events umgeht, ... damit sie sich nicht vermischen.

Wenn Sie Software plotten müssen, können Sie versuchen, matplotlib zu verwenden, um statische Grafiken zu generieren und das Bild in PyQt anzuzeigen. Oder probieren Sie ein PyQt-basiertes Diagramm oder Plot-Toolkit aus.


-1
2018-01-27 16:59