पायथन: पीईक्यूटी 4 में चैको एम्बेड करें रहस्य

Question

मैं मौजूदा पीक्यूटी 4 एप्लिकेशन में चाको जोड़ने के बारे में कैसे जा सकता हूं?

खोजों के घंटे कम (search for yourself) उत्पन्न हुए। अब तक मैं समझ गए होंगे मैं निम्नलिखित लाइनों की जरूरत है:

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

मैं PyQt4-चाको कोड कहीं भी इन्टरनेट

मैं रिक्त स्थान को भरने के किसी को भी मुझे दिखाने के लिए करने के लिए बहुत आभारी होंगे पर नहीं मिल सका सरल रेखा भूखंड संभव (2 के साथ अंक)

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

क्या चाको/Enthought वर्ग QWidget से विरासत?

Answer 1

यहाँ तुम क्या जरूरत है:

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 QWidget

Answer 2

मुझे चाको नहीं पता लेकिन एक त्वरित रूप मुझे बताती है कि यह संभव नहीं है।

चाको और पीईक्यूटी दोनों उपयोगकर्ता के साथ बातचीत करने के लिए डिज़ाइन किए गए ग्राफिकल टूलकिट हैं। चाको प्लॉट उन्मुख है और पीईक्यूटी अधिक आवेदन उन्मुख है। प्रत्येक व्यक्ति का प्रबंधन करने का अपना तरीका है कि खिड़की क्या है, उपयोगकर्ता क्लिक का पता लगाने के लिए, पेंट इवेंट्स को कैसे संभालना है, ताकि वे एक साथ मिश्रण न करें।

यदि आपको साफ्टवेयर सॉफ़्टवेयर की आवश्यकता है, तो आप ग्राफ की स्थिर छवियां उत्पन्न करने और पीईक्यूटी में छवि दिखाने के लिए मैटलप्लिब का उपयोग करने का प्रयास कर सकते हैं। या एक पीईक्यूटी आधारित ग्राफ या साजिश टूलकिट आज़माएं।

Answer 3

मुझे चाको के बारे में पता नहीं है, लेकिन मैं वीटीके का उपयोग कर रहा हूं, यहां कुछ लाइनों को आकर्षित करने के लिए कोड है, जिसमें उनमें से एक (x, y, z) निर्देशांक है।

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

यह PyQt4 के साथ बातचीत करने QVTKRenderWindowInteractor उपयोग करता है।

Answer 4

से विरासत मैं सिर्फ यह आज देखा। यह क्यूटी के साथ-साथ डब्ल्यूएक्स के अंदर चाको को एम्बेड करने के लिए बिल्कुल संभव और काफी सरल है। वास्तव में, सभी उदाहरण, जब आपके ETS_TOOLKIT पर्यावरण var के साथ चलाते हैं तो "qt4" पर सेट होता है, यह बिल्कुल ठीक कर रहे हैं। (चाको वहाँ की आवश्यकता है एक अंतर्निहित जीयूआई टूलकिट किया जाना है।)

मैं एक छोटे से, स्टैंडअलोन उदाहरण है कि अपने कोड टेम्पलेट में रिक्त स्थान को भरता है, और यह दर्शाता है एक क्यूटी खिड़की के अंदर एक चाको प्लॉट एम्बेड करने के लिए कैसे लिखा है। 'इंटरैक्टिव सक्षम' चाको अपने डिजाइन में 3. विचित्र रूप

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