मायावी में एक रंगीन घन आकर्षित करें

1. # PyQt4 विजेट में एम्बेड करने के लिए, आपको ETS_TOOLKIT चर को qt4 पर सेट करना होगा।
2. आयात os
3. ओएस । environ [ 'ETS_TOOLKIT' ] = 'qt4'
4. PySide इंपोर्ट से QtGui, QtCore
6. उत्साह से। मायावी मलबे का आयात करती हैं
7. उत्साह से। tvtk । एपीआई आयात tvtk
8. उत्साह से। tvtk । चिता । आपी आयात दृश्य
9. नंबरी इंपोर्ट अरेंज, नॉनजेरो, फ्लोट 32, मिन , मैक्स , मीडियन, कॉपी , रैंडम , शेप से
10. सुन्न से। कोर । संख्यात्मक आयात
12. उत्साह से। लक्षण । Api आयात HasTraits, इंस्टेंस, on_trait_change, \
13. इंट, तानाशाही
14. उत्साह से। लक्षण । ui । एपीआई आयात देखें, आइटम
15. उत्साह से। मायावी । कोर । ui । एपीआई आयात मायावीसेन, MlabSceneModel, \
16. SceneEditor
18. # वास्तविक दृश्य
19. क्लास विज़ुअलाइज़ेशन ( HasTraits ) :
20. दृश्य = उदाहरण ( MlabSceneModel, ( ) )
21. दृश्य = दृश्य ( आइटम) ( 'दृश्य') ,
22. संपादक = दृश्यदर्शी ( दृश्य_क्लास = मायावीसेन ) ,
23. # मायावीसेन की जगह आप सिर्फ सीन लिख सकते हैं
24. # और फिर हमें टूलबार के बिना एक साफ विंडो मिलती है।
25. ऊंचाई = 250 ,
26. चौड़ाई = 300 ,
27. show_label = गलत ) ,
28. resizable = सत्य
29. )
31. needUpdate = कोई नहीं
33. डीईएफ़्लोटप्रेमेट्रेस ( सेल्फ , ग्रिड ) :
34. स्व । ग्रिड = ग्रिड
36. # सीएलएफ () विधि वर्तमान दृश्य को साफ करती है। इसे अपडेट_प्लॉट () विधि में नहीं कहा जा सकता
37. स्व । दृश्य । मिलीब । clf ( )
38. स्व । needUpdate = सत्य
40. स्व । update_plot ( )
42. @on_trait_change ( 'दृश्य.संयुक्त' )
43. def update_plot ( self ) :
44. # इस विधि को प्रतिपादन के लिए कहा जाता है।
45. # जो कुछ भी तैयार करने की आवश्यकता है वह यहाँ और कहीं नहीं लिखा गया है
47. # जबकि कोई डेटा नहीं है, हम मानक मॉडल तैयार करेंगे
48. यदि स्व नहीं । जरूरत :
49. स्व । दृश्य । मिलीब । test_point3d ( )
50. और :
51. # यहां हम अपने सभी चावल कुकर लिखते हैं
53. # सब कुछ जो मलबे के माध्यम से प्रस्तुत किया जाता है, उसे बुलाया जाना चाहिए
54. # जैसे self.scene.mlab। *, अन्यथा मायावी विंडो नियंत्रण से बाहर हो जाती है
55. # और एक अलग विंडो में सब कुछ आकर्षित करना शुरू कर देता है।
56. # अस्पष्टता प्रतिपादन प्रदर्शन को बहुत प्रभावित करती है!
57. सर्फ = स्व । दृश्य । मिलीब । पाइपलाइन । सतह ( स्वयं ग्रिड , अपारदर्शिता = 1 )
59. # आप लाइनों को जोड़कर आंतरिक ग्रिड को भी प्रदर्शित कर सकते हैं
60. #edges = mlab.pipeline.extract_edges (सर्फ)
61. #edgesSurf = mlab.pipeline.surface (किनारों)
62. # किनारोंसर्फ.क्टोर .property.interpolation = 'फ्लैट'
64. # हम घन की सतह के रंग के प्रक्षेप को हटाते हैं। प्रत्येक कोशिका को स्पष्ट रूप से देखा जाए।
65. सर्फ। अभिनेता । संपत्ति । प्रक्षेप = 'समतल'
67. स्व । दृश्य । मिलीब । ओरिएंटेशन_एक्सेस ( )
68. स्व । दृश्य । पृष्ठभूमि = ( 0 , 0 , 0 )
69. स्व । दृश्य । मिलीब । colorbar ( ओरिएंटेशन = 'वर्टिकल' )
72. ################################################## ##############################
73. # विजेट जिसमें दृश्य को एम्बेड करना है। हम इसे एक नियमित PyQt विजेट के रूप में उपयोग करते हैं।
75. वर्ग मायावीक्वेटगेट ( QtGui। QWidget ) :
76. def __init__ ( स्व , माता-पिता = कोई नहीं ) :
77. QtGui। QWidget । __in__ ( स्व , माता-पिता )
78. लेआउट = QtGui। QVBoxLayout ( स्व )
79. लेआउट। सेटमैर्जिन ( 0 )
80. लेआउट। setSpacing ( 0 )
81. स्व । विज़ुअलाइज़ेशन = विज़ुअलाइज़ेशन ( )
83. # आदर्श रूप में, यह वह जगह है जहां आप प्रारंभिक डेटा के साथ टेकप्लॉटमेटम पद्धति को कॉल कर सकते हैं, लेकिन यह आवश्यक नहीं है
84. # self.visualization.takePlotParametres ()
86. # Edit_traits विधि उस विंडो को उत्पन्न करती है जिसमें दृश्य बनाया गया है।
87. # इस विंडो को क्यूटीएच बनाया जाना चाहिए, जिसके लिए हम .control विधि कहते हैं
88. स्व । उई = स्व । दृश्य । edit_traits ( मूल = स्व ,
89. kind = 'subpanel' ) । नियंत्रण
90. लेआउट। AddWidget ( स्व । यूई )
91. स्व । ui । सेटपरेंट ( स्व )
93. def create_cube ( स्वयं ) :
94. ग्रिड = स्व । createGrid ( )
96. स्व । दृश्य । takePlotParametres ( ग्रिड )
98. def createGrid ( स्वयं ) :
99. x, y, z = ( 10 , 10 , 10 )
101. # हमारे घन के लिए एक ग्रिड बनाएँ
102. ग्रिड = tvtk। रेक्टिलिनियरग्रिड ( )
104. # फ्लोट 32 तक डेटा डालना महत्वपूर्ण है, जैसा कि 64-बिट OS पर, numpy डिफ़ॉल्ट रूप से float64 बनाता है,
105. # और मायावी को नहीं पता कि इसके साथ कैसे काम करना है।
106. # रैंडम डेटा बनाएं
107. स्केलर = फ्लोट 32 ( यादृच्छिक । यादृच्छिक ( ( x * y * z ) ) )
109. # स्केलर्स वह मूल्य है जो हमारे घन के प्रत्येक सेल में संग्रहीत किया जाएगा।
110. # यह इस मूल्य पर है कि कोशिकाओं की सतह का रंग निर्धारित किया जाता है
111. ग्रिड। point_data। scalars = स्केलर
112. ग्रिड। point_data। स्केलर । नाम = 'स्केलर'
114. ग्रिड। आयाम = ( एक्स, वाई, जेड )
115. ग्रिड। x_coordinates = float32 ( arange ( x ) )
116. ग्रिड। y_coordinates = float32 ( arange ( y ) )
117. ग्रिड। z_coordinates = float32 ( arange ( z ) )
119. वापसी ग्रिड
121. अगर __name__ == "__main__" :
122. # नया एप्लिकेशन बनाना महत्वपूर्ण नहीं है, बल्कि कुछ का उपयोग करना है
123. # जो मायावी स्वचालित रूप से बनाता है, अन्यथा आप सभी लक्षण संकेतों / स्लॉट्स को मार देंगे,
124. # और हमें इसकी आवश्यकता नहीं है।
125. # लिंक प्राप्त करने के लिए, उदाहरण () विधि को कॉल करें।
126. # आदत से बाहर न लिखें QtGui.QApplication (sys.argv) .instance ()
127. # मैंने पहले ही इस रेक पर कदम रखा।
128. app = QtGui। प्रश्नोत्तर । उदाहरण ( )
130. कंटेनर = क्यूटीगुई। QWidget ( )
131. कंटेनर। setWindowTitle ( "हेलो हैब्राहाब !" )
132. लेआउट = QtGui। QVBoxLayout ( कंटेनर )
134. mayavi_widget = MayaviQWidget ( )
136. बटन = QtGui। QPushButton ( 'क्यूब बनाएँ' )
137. बटन। क्लिक किया । कनेक्ट ( mayavi_widget। create_cube )
139. लेआउट। AddWidget ( mayavi_widget )
140. लेआउट। AddWidget ( बटन )
142. कंटेनर। दिखाना ( )
144. एप्लिकेशन। निष्पादित_ ( )