🧚🏽 👩‍👩‍👦‍👦 🗺️ चाको में ड्राइंग चार्ट 👊🏽 ▫️ ✒️

आज मैं आपको चाको नामक एक अद्भुत कार्यक्रम के बारे में बताऊंगा, जिसे उत्साह से विकसित किया गया है।

चाको पायथन में किसी भी जटिलता के ग्राफ बनाने के लिए एक क्रॉस-प्लेटफ़ॉर्म एप्लिकेशन है। यह स्थैतिक डेटा प्रदान करने पर केंद्रित है, लेकिन इसमें एनिमेशन बनाने की क्षमता भी है।

जैसे मायावी Wx और Qt (PyQt और PySide) अनुप्रयोगों में एकीकृत हो सकता है, यह Numpy सरणियों के साथ दोस्त है।

स्थापना

पहला कदम चाको को स्थापित करना है। हम निर्भरताएं डालते हैं: गिट, तोड़फोड़, सेटपूल, स्विग, सुपी, स्कैपी, वीटीके, wxpython। विंडोज के लिए, आपको विन के लिए mingw (vtk और wxpython) स्थापित करने की आवश्यकता होगी, मैं आपको सलाह देता हूं कि समय बचाने के लिए www.lfd.uci.edu/~gohlke/pythonlibs यहां से लें)। हम ईटीएस उत्पादों को जीआईटी से हटाते हैं (अनावश्यक हटाया जा सकता है):

mkdir ets && cd ets
wget github.com/enthought/ets/raw/master/ets.py
python ets.py clone

फिर हम इस पूरी चीज़ को इकट्ठा करते हैं:

python ets.py develop

आपको कुछ और वितरित करना पड़ सकता है, यहां आपको बिल्ड लॉग को देखने की आवश्यकता है। क्या गायब था, विधानसभा को फिर से स्थापित और चलाएं।

उदाहरण

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

मैं केवल कुछ असामान्य ग्राफिक्स का वर्णन करूंगा जिन्हें आप चाको में बना सकते हैं:

वित्तीय:

यह उदाहरण PySide विजेट में एम्बेडिंग का उपयोग करता है।

# - * - कोडिंग: utf-8 - * _ 
 
# से पहले pyside पर QT_API वैरिएबल सेट करना महत्वपूर्ण है
# कैसे चाको मॉड्यूल आयात किए जाते हैं 
आयात os 
ओएस । environ [ 'QT_API' ] = 'pyside' 
ओएस । environ [ 'ETS_TOOLKIT' ] = 'qt4' 
PySide के आयात से QtGui, QtCore 
 
सुन्न आयात से पेट , arange, cumprod, यादृच्छिक 
सक्षम से। example_support आयात DemoFrame, Demo_main 
सक्षम से। एपीआई आयात खिड़की, घटक, घटक यंत्र 
लक्षणों से। एपीआई आयात हैट्रेट्स, इंस्टेंस 
ट्रिटसुई से। एपीआई आयात आइटम, समूह, देखें 
चाको से। एपीआई आयात ArrayDataSource, BarPlot, DataRange1D, \ 
लिनियरमैपर, VPlotContainer, PlotAxis, FilledLinePlot, \ 
add_default_grids, PlotLabel 
चाको से। उपकरण । एपीआई आयात पैनटूल, ज़ूमटूल 
 
# एक फ़ंक्शन जो ग्राफ़ के साथ एक कंटेनर बनाता है 
def _create_plot_component ( ) : 
 
# ग्राफ़ के लिए यादृच्छिक मान बनाएं 
संख्या = 500 
index = arange ( संख्याएँ ) 
रिटर्न = यादृच्छिक । lognormal ( 0.01 , 0.1 , size = numpoint ) 
मूल्य = 100.0 * cumprod ( रिटर्न ) 
मात्रा = अनुप ( यादृच्छिक । सामान्य ( 1000.0 , 1500.0 , आकार = संख्या ) + 2000.0 ) 
 
# ArrayDataSource - ये ऐसी सरणियाँ हैं जो हमारे डेटा को स्टोर करती हैं
time_ds = ArrayDataSource ( इंडेक्स ) 
vol_ds = ArrayDataSource ( वॉल्यूम, सॉर्ट_ऑर्डर = "कोई नहीं" ) 
price_ds = ArrayDataSource ( मूल्य, सॉर्ट_ऑर्डर = "कोई नहीं" ) 
 
# रैखिकमीटर - ये अक्ष के हस्ताक्षर सरणियाँ हैं
xmapper = LinearMapper ( श्रेणी = DataRange1D ( time_ds ) ) 
vol_mapper = LinearMapper ( श्रेणी = DataRange1D ( vol_ds ) ) 
price_mapper = LinearMapper ( श्रेणी = DataRange1D ( price_ds ) ) 
 
# चार्ट के नीचे के क्षेत्र में भरने के साथ FilledLinePlot प्रकार का मूल्य चार्ट 
price_plot = FilledLinePlot ( index = time_ds, value = price_ds, 
index_mapper = xmapper, 
value_mapper = price_mapper, 
edge_color = "ब्लू" , 
face_color = "paleturquoise" , 
bgcolor = "सफेद" , 
बॉर्डर_विशेष = सत्य ) 
 
# ग्रिड और कुल्हाड़ी जोड़ें 
add_default_grids ( price_plot ) 
price_plot। ओवरले । परिशिष्ट ( प्लॉटएक्सिस ( price_plot, ओरिएंटेशन = 'लेफ्ट' ) ) 
price_plot। ओवरले । परिशिष्ट ( प्लॉटएक्सिस ( price_plot, ओरिएंटेशन = 'निचला' ) ) 
 
# चार्ट को स्थानांतरित करने की क्षमता जोड़ें 
price_plot। उपकरण । append ( PanTool ( price_plot, constrain = True , )
constrain_direction = "x" ) ) 
# ज़ूम जोड़ें 
price_plot। ओवरले । append ( ZoomTool ( price_plot, drag_button = "right" , )
हमेशा_न = सत्य , 
tool_mode = "श्रेणी" , 
ax = "index" ) ) 
 
# BarPlot - बार चार्ट 
vol_plot = BarPlot ( index = time_ds, value = vol_ds, 
index_mapper = xmapper, 
value_mapper = vol_mapper, 
line_color = "पारदर्शी" , 
fill_color = "ब्लैक" , 
bar_width = 1.0 , 
bar_width_type = "स्क्रीन" , 
antialias = गलत , 
ऊँचाई = 100 , 
resizable = "h" , 
bgcolor = "सफेद" , 
बॉर्डर_विशेष = सत्य ) 
 
# ग्रिड और कुल्हाड़ी जोड़ें 
add_default_grids ( vol_plot ) 
vol_plot। रेखांकित करता है । परिशिष्ट ( प्लॉटएक्सिस ( vol_plot, ओरिएंटेशन = 'लेफ्ट' ) ) 
vol_plot। उपकरण । append ( PanTool ( vol_plot, constrain = True , )
constrain_direction = "x" ) ) 
 
# कंटेनर - हमारे ग्राफ़ की एक सरणी, उनके स्थान को नियंत्रित करता है 
कंटेनर = VPlotContainer ( bgcolor = "lightblue" , 
रिक्ति = 20 , 
गद्दी = 50 , 
fill_padding = गलत ) 
कंटेनर। add ( vol_plot ) 
कंटेनर। add ( price_plot ) 
# कंटेनर के ऊपर कैप्शन जोड़ें 
कंटेनर। ओवरले । परिशिष्ट ( प्लॉटलैबेल ( "वित्तीय प्लॉट" , 
घटक = कंटेनर, 
फ़ॉन्ट = "एरियल 24" ) ) 
वापसी कंटेनर 
 
 
वर्ग डेमो ( HasTraits ) : 
# HasTraits एक विशेष लक्षण शब्दावली वर्ग है जो को जोड़ता है
# किसी हैंडलर के साथ। 
प्लॉट = इंस्टेंस ( घटक ) 
 
# देखें - हमारे रेखांकन की प्रस्तुति। 
traits_view = दृश्य ( )
समूह ( 
आइटम ( 'प्लॉट' , एडिटर = कंपोनेंट एडिटर ( आकार = ( 800 , 600 ) ) , 
show_label = गलत ) , 
ओरिएंटेशन = "वर्टिकल" ) , 
resizable = True 
) 
 
def _plot_default ( self ) : 
# कंटेनर / ग्राफ़ जो डिफ़ॉल्ट रूप से प्रस्तुत किया गया है 
वापसी _create_plot_component ( ) 
 
# उस मानक विंडो पर टिप्पणी करें जिसमें रेखांकन खींचे गए हैं। 
#क्लास प्लॉटफ़्रेम (डेमोफ्रेम): 
# 
# def _create_window (स्व): 
# # एक विंडो बनाता है जिसमें रेखांकन ड्रा करने के लिए 
# रिटर्न विंडो (स्वयं, -1, घटक = _create_plot_component ()) 
 
वर्ग ChacoQWidget ( QtGui। QWidget ) : 
def __init__ ( स्व , माता-पिता = कोई नहीं ) : 
QtGui। QWidget । __in___ ( स्व , माता-पिता ) 
लेआउट = QtGui। QVBoxLayout ( स्व ) 
फ्रेम = डेमो ( ) 
# अब हमें एक विजेट बनाने की जरूरत है, जिसके लिए हम कंट्रोल फंक्शन को कहते हैं
# जादू इसके बिना काम नहीं करता है :) 
उई = ढाँचा। edit_traits ( जनक = स्व , दयालु = 'उपप्राण' ) । नियंत्रण 
लेआउट। addWidget ( ui ) 
लेआउट। addWidget ( QtGui। QPushButton ( "हेलो हब्रह्रब " ) ) 
 
अगर __name__ == "__main__" : 
#demo_main (प्लॉटफ़्रेम, आकार = (800, 600), शीर्षक = "वित्तीय प्लॉट उदाहरण" 
app = QtGui। प्रश्नोत्तर । उदाहरण ( ) 
w = ChacoQWidget ( ) 
डब्ल्यू। आकार ( 800 , 600 ) 
डब्ल्यू। शो ( ) 
एप्लिकेशन। निष्पादित_ ( )
ग्राफ़ के लिए रंगों का चयन (मैं एनीमेशन लागू करूँगा, लेकिन वास्तव में, माउस स्क्रॉल के अनुसार सब कुछ बदल जाता है):

numpy आयात arange से, exp, सॉर्ट 
सुन्न से। यादृच्छिक आयात यादृच्छिक 
सक्षम से। example_support आयात DemoFrame, Demo_main 
सक्षम से। एपीआई आयात घटक, घटक संधारित्र, विंडो 
लक्षणों से। एपीआई आयात हैट्रेट्स, इंस्टेंस 
ट्रिटीसुई से। एपीआई आयात आइटम, समूह, देखें 
चाको से। एपीआई आयात ArrayPlotData, ColorBar, \ 
ColormappedSelectionOverlay, HPlotContainer, \ 
जेट, लीनियरमैपर, प्लॉट, जिस्ट_अर्थ 
चाको से। उपकरण । एपीआई आयात पैनटूल, जूमटूल, रेंजसेलेक्शन, \ 
RangeSelectionOverlay 
 
# ==================================================== ================================ 
# # चाको की साजिश रचें। 
# ==================================================== ================================ 
def _create_plot_component ( ) : 
 
# कुछ डेटा बनाएं 
संख्या = 1000 
x = सॉर्ट ( यादृच्छिक ( अंक ) ) 
y = यादृच्छिक ( अंक ) 
color = exp ( - ( x ** 2 + y ** 2 ) ) 
 
# एक भूखंड डेटा अवरोध बनाएँ और इसे यह डेटा दें 
pd = ArrayPlotData ( ) 
पीडी। set_data ( "इंडेक्स" , x ) 
पीडी। set_data ( "मान" , y ) 
पीडी। set_data ( "रंग" , रंग ) 
 
# प्लॉट बनाएं 
प्लॉट = प्लॉट ( पीडी ) 
साजिश। प्लॉट ( "इंडेक्स" , "वैल्यू" , "कलर" ) , 
प्रकार = "cmap_scatter" , 
नाम = "my_plot" , 
color_mapper = gist_earth, 
मार्कर = "वर्ग" , 
fill_alpha = 0.5 , 
मार्कर_साइज़ = 8 , 
outline_color = "ब्लैक" , 
बॉर्डर_विजय = सत्य , 
bgcolor = "व्हाइट" ) 
 
# कथानक के कुछ गुणों को मोड़ दें 
साजिश। शीर्षक = "पैन / ज़ूम कलर बार" के साथ कॉलर्म्ड स्कैटर प्लॉट
साजिश। गद्दी = 50 
साजिश। x_grid दृश्यमान = गलत 
साजिश। y_grid दृश्यमान = गलत 
साजिश। x_axis । फ़ॉन्ट = "आधुनिक 16" 
साजिश। y_axis फ़ॉन्ट = "आधुनिक 16" 
 
# पैन जोड़ें और भूखंड पर ज़ूम करें 
साजिश। उपकरण । append ( PanTool ( भूखंड, विवश_ = "बदलाव" ) ) 
ज़ूम = ज़ूमटूल ( प्लॉट ) 
साजिश। ओवरले । परिशिष्ट ( ज़ूम ) 
 
# उपयुक्त रेंज और कोलरमैप में हैंडलबार को कलरबार बनाएं
colorbar = ColorBar ( index_mapper = LinearMapper ( श्रेणी = साजिश। color_mapper । श्रेणी ) , ।
color_mapper = कथानक। color_mapper , 
ओरिएंटेशन = 'v' , 
resizable = 'v' , 
चौड़ाई = 30 , 
गद्दी = 20 ) 
colorbar। प्लॉट = प्लॉट 
colorbar। पेडिंग_टॉप = प्लॉट। पेडिंग_टॉप 
colorbar। पेडिंग_बॉटम = प्लॉट। पेडिंग_बॉटम 
 
# कलरबार में पैन और जूम टूल जोड़ें
colorbar। उपकरण । append ( PanTool ( colorbar, constrain_direction = "y" , constrain = True ) ) 
zoom_overlay = ZoomTool ( colorbar, axis = "index" , tool_mode = "range" , 
always_on = True , drag_button = "दाएँ" ) 
colorbar। ओवरले । परिशिष्ट ( zoom_overlay ) 
 
# प्लॉट और कलरबार को साथ-साथ रखने के लिए एक कंटेनर बनाएं 
कंटेनर = HPlotContainer ( प्लॉट, कलरबार, use_backbuffer = True , bgcolor = " lightgray " ) 
 
वापसी कंटेनर 
 
# ==================================================== ================================ 
# प्लॉट दृश्य के लिए उपयोग करने के लिए विशेषताएँ। 
आकार = ( 650 , 650 ) 
शीर्षक = "गोलमाल बिखेरने की साजिश" 
 
# ==================================================== ================================ 
# # डेमो क्लास जिसका उपयोग डेमोक्रोम एप्लिकेशन द्वारा किया जाता है। 
# ==================================================== ================================ 
वर्ग डेमो ( HasTraits ) : 
प्लॉट = इंस्टेंस ( घटक ) 
 
traits_view = दृश्य ( )
समूह ( 
आइटम ( 'प्लॉट' , संपादक = कंपोनेंट एडिटर ( आकार = आकार ) , 
show_label = गलत ) , 
ओरिएंटेशन = "वर्टिकल" ) , 
resizable = true , शीर्षक = शीर्षक 
) 
 
def _plot_default ( self ) : 
वापसी _create_plot_component ( ) 
 
डेमो = डेमो ( ) 
 
# ==================================================== ================================ 
# प्लॉट प्रदर्शित करने के लिए स्टैंड-अलोन फ्रेम। 
# ==================================================== ================================ 
वर्ग प्लॉटफ़्रेम ( डेमोफ्रेम ) : 
 
def _create_window ( स्व ) : 
# हमारे भूखंडों वाली एक खिड़की लौटें 
वापसी खिड़की ( स्वयं , - 1 , घटक = _create_plot_component ( ) ) 
 
अगर __name__ == "__main__" : 
Demo_main ( प्लॉटफ़्रेम, आकार = आकार, शीर्षक = शीर्षक )
ध्रुवीय निर्देशांक में रेखांकन:

कोड:
खसखस से आयात arange, पी, पाप, cos 
उत्साह से। सक्षम करें । example_support आयात DemoFrame, Demo_main 
उत्साह से। सक्षम करें । एपीआई आयात विंडो 
उत्साह से। लक्षण । एपीआई आयात गलत 
उत्साह से। चाको । एपीआई आयात create_polar_plot 
 
वर्ग MyFrame ( DemoFrame ) : 
def _create_window ( स्व ) : 
संख्या = 5000 
कम = 0 
high = pi * 2 
थीटा = अरेंज ( निम्न, उच्च, ( उच्च-निम्न ) / अंक ) 
त्रिज्या = पाप ( थीटा * 3 ) 
 
प्लॉट = create_polar_plot ( ( त्रिज्या, थीटा ) , रंग = ( 0.0 , 0.0 , 1.0 , 1 ) , चौड़ाई = 4.0 ) 
साजिश। bgcolor = "सफेद" 
वापसी खिड़की ( स्वयं , - 1 , घटक = प्लॉट ) 
 
अगर __name__ == "__main__" : 
डेमो_मैन ( MyFrame, आकार = ( 600 , 600 ) , शीर्षक = "सरल ध्रुवीय प्लॉट" )
विभिन्न बहुभुज:

आयात गणित 
सुन्न आयात सरणी से , स्थानांतरण 
सक्षम से। example_support आयात DemoFrame, Demo_main 
सक्षम से। एपीआई आयात घटक, घटक संधारित्र, विंडो 
लक्षणों से। एपीआई आयात हैट्रेट्स, इंस्टेंस, एनम, कैरे, डिक्ट 
ट्रिटसुई से। एपीआई आयात आइटम, समूह, देखें 
चाको से। एपीआई आयात ArrayPlotData, HPlotContainer, प्लॉट 
चाको से। आधार आयात n_gon 
चाको से। उपकरण । एपीआई आयात पैनटूल, जूमटूल, ड्रैगटूल 
 
क्लास डाटापेसमोवटूल ( ड्रैगटूल ) : 
"" " 
एक भूखंड के डेटा मूल्यों को संशोधित करता है। केवल उदाहरणों पर काम करता है 
BaseXYPlot या उसके उपवर्ग के आधार पर
"" " 
 
event_state = Enum ( "सामान्य" , "खींचना" ) 
_prev_pt = CArray 
 
def_draggable ( स्व , x, y ) : है
स्व लौट आओ । घटक । hittest ( ( x, y ) ) 
 
def drag_start ( self , event ) : 
data_pt = स्व । घटक । map_data ( ( event.x, event.y ) , all_values = True ) 
self ._prev_pt = data_pt 
घटना। संभाला = सच 
 
def ड्रैगिंग ( स्व , ईवेंट ) : 
कथानक = स्व । घटक 
cur_pt = कथानक। map_data ( ( event.x, event.y ) , all_values = True ) 
dx = cur_pt [ 0 ] - self._prev_pt [ 0 ] 
dy = cur_pt [ 1 ] - self__prev_pt [ 1 ] 
सूचकांक = कथानक। सूचकांक । get_data ( ) + dx 
मूल्य = कथानक। मान । get_data ( ) + डाई 
साजिश। सूचकांक । set_data ( इंडेक्स, सॉर्ट_ऑर्डर = प्लॉट। इंडेक्स । सॉर्ट_ऑर्डर ) 
साजिश। मान । set_data ( मान, सॉर्ट_ऑर्डर = प्लॉट। मान । सॉर्ट_ऑर्डर ) 
self ._prev_pt = cur_pt 
घटना। संभाला = सच 
साजिश। request_redraw ( ) 
 
 
# ==================================================== ================================ 
# # चाको की साजिश रचें। 
# ==================================================== ================================ 
def _create_plot_component ( ) : 
 
# हमारे बहुभुज के लिए केंद्र स्थानों की गणना करने के लिए n_gon का उपयोग करें
अंक = n_gon ( केंद्र = ( 0 , 0 ) , r = 4 , nsides = 
 
# हमारे बहुभुज के लिए कुछ रंगों का चयन करें
रंग = { 3 : 0xabbcc, 4 : 'नारंगी' , 5 : 'पीला' , 6 : 'लाइटग्रीन' , 
7 : 'ग्रीन' , 8 : 'ब्लू' , 9 : 'लैवेंडर' , 10 : 'पर्पल' } 
 
# बहुभुज डेटा को स्टोर करने के लिए एक प्लॉटडाटा ऑब्जेक्ट बनाएं 
pd = ArrayPlotData ( ) 
 
# नियमित बहुभुज बनाने के लिए एक बहुभुज प्लॉट बनाएं 
पॉलिप्लॉट = प्लॉट ( पीडी ) 
 
# प्रत्येक बहुभुज के लिए पथ डेटा स्टोर करें, और प्लॉट करें
nsides = 3 
अंक में p के लिए : 
npoint = n_gon ( केंद्र = p, r = 2 , nsides = nsides ) 
nxarray, nyarray = transpose ( npoint ) 
पीडी। set_data ( "x" + str ( nsides ) , nxarray ) 
पीडी। set_data ( "y" + str ( nsides ) , nyarray ) 
प्लॉट = पॉलीपोट। प्लॉट ( "x" + str ( nsides ) , "y" + str ( nsides ) ) , 
प्रकार = "बहुभुज" , 
face_color = रंग [ nsides ] , 
hittest_type = "poly" ) [ 0 ] 
साजिश। उपकरण । परिशिष्ट ( DataspaceMoveTool ( प्लॉट, ड्रैग_बटन = "सही" ) ) 
nsides = nsides + 1 
 
# कथानक के कुछ गुणों को मोड़ दें 
polyplot। गद्दी = 50 
polyplot। शीर्षक = "बहुभुज प्लॉट" 
 
# भूखंड के लिए कुछ उपकरण संलग्न करें 
polyplot। उपकरण । परिशिष्ट ( PanTool ( पॉलीप्लॉट ) ) 
ज़ूम = ज़ूमटूल ( पॉलीपोट, टूल_मोड = "बॉक्स" , हमेशा_ओन = गलत ) 
polyplot। ओवरले । परिशिष्ट ( ज़ूम ) 
 
पॉलिप्लॉट वापस करें
 
# ==================================================== ================================ 
# प्लॉट दृश्य के लिए उपयोग करने के लिए विशेषताएँ। 
आकार = ( 800 , 800 ) 
शीर्षक = "बहुभुज प्लॉट" 
 
# ==================================================== ================================ 
# # डेमो क्लास जिसका उपयोग डेमोक्रोम एप्लिकेशन द्वारा किया जाता है। 
# ==================================================== ================================ 
वर्ग डेमो ( HasTraits ) : 
प्लॉट = इंस्टेंस ( घटक ) 
 
traits_view = दृश्य ( )
समूह ( 
आइटम ( 'प्लॉट' , संपादक = कंपोनेंट एडिटर ( आकार = आकार ) , 
show_label = गलत ) , 
ओरिएंटेशन = "वर्टिकल" ) , 
resizable = true , शीर्षक = शीर्षक 
) 
 
def _plot_default ( self ) : 
वापसी _create_plot_component ( ) 
 
डेमो = डेमो ( ) 
 
# ==================================================== ================================ 
# प्लॉट प्रदर्शित करने के लिए स्टैंड-अलोन फ्रेम। 
# ==================================================== ================================ 
वर्ग प्लॉटफ़्रेम ( डेमोफ्रेम ) : 
 
def _create_window ( स्व ) : 
# हमारे भूखंडों वाली एक खिड़की लौटें 
वापसी खिड़की ( स्वयं , - 1 , घटक = _create_plot_component ( ) ) 
 
अगर __name__ == "__main__" : 
Demo_main ( प्लॉटफ़्रेम, आकार = आकार, शीर्षक = शीर्षक )
एक्स-रे:

__future__ से आयात करें with_statement 
आयात सुन्न 
लक्षणों से। एपीआई आयात हैट्रेट्स, इंस्टेंस, Enum 
ट्रिटीसुई से। एपीआई आयात देखें, आइटम 
सक्षम से। एपीआई आयात घटक ई-कॉमर्स 
चाको से। एपीआई आयात प्लॉट, ArrayPlotData, AbstractOverlay 
सक्षम से। एपीआई आयात बेसटूल 
सक्षम से। मार्कर DOT_MARKER, DotMarker आयात करते हैं
 
वर्ग BoxSelectTool ( बेसटूल ) : 
"" "बॉक्स के सभी बिंदुओं को चुनने के लिए टूल 
 
इस उपकरण के लिए 2 राज्य हैं, सामान्य और चयन। जबकि 
बाईं माउस बटन मेटाडेटा नीचे है डेटा स्रोत पर होगा
वर्तमान चयनित सीमा के साथ अद्यतन किया गया। 
 
ध्यान दें कि उपकरण वास्तव में चयनित बिंदु को संग्रहीत नहीं करता है, लेकिन 
बॉक्स की सीमा। 
"" " 
 
event_state = Enum ( "सामान्य" , "चयन" ) 
 
def normal_left_down ( स्वयं , घटना ) : 
स्व । event_state = "चयन" 
स्व । select_mouse_move ( घटना ) 
 
def select_left_up ( स्वयं , ईवेंट ) : 
स्व । event_state = "सामान्य" 
 
def_mouse_move ( स्वयं , घटना ) का चयन करें: 
एक्स 1, वाई 1 = स्व । map_to_data ( event.x - 25 , event.y - 25 ) 
x2, y2 = स्व । map_to_data ( घटना। x + 25 , घटना। y + 25 ) 
 
index_datasource = स्व । घटक । सूचकांक 
index_datasource। मेटाडेटा [ 'चयन' ] = ( X1, x2 ) 
 
value_datasource = स्व । घटक । मान 
value_datasource। मेटाडेटा [ 'चयन' ] = ( y1, y2 ) 
 
स्व । घटक । request_redraw ( ) 
 
def map_to_data ( स्वयं , x, y ) : 
"" "दिए गए x और y के डेटा स्पेस निर्देशांक लौटाता है। 
 
भूखंड की धुरी और अक्षीय सेटिंग को ध्यान में रखता है। 
"" " 
 
कथानक = स्व । घटक 
अगर साजिश है। अभिविन्यास == "एच" : 
सूचकांक = कथानक। x_mapper। map_data ( x ) 
मूल्य = कथानक। y_mapper। map_data ( y ) 
और : 
सूचकांक = कथानक। y_mapper। map_data ( y ) 
मूल्य = कथानक। x_mapper। map_data ( x ) 
 
वापसी सूचकांक, मान 
 
 
क्लास एक्सरेओवरले ( एब्सट्रैक्टले ) : 
"" "ओवरले जो कथानक डेटा बिंदुओं के शीर्ष पर तितर बितर मार्करों को खींचता है। 
 
इस ओवरले को एक टूल के साथ जोड़ा जाना चाहिए जो को अपडेट करता है
मेटाडेटा चयन सीमा के साथ डेटा स्रोत। 
"" " 
 
मार्कर = डॉटमार्कर ( ) 
 
def ओवरले ( स्वयं , घटक, gc , view_bounds = कोई नहीं , मोड = 'सामान्य' ) : 
x_range = self_get_selection_index_screen_range ( ) 
y_range = self_get_selection_value_screen_range ( ) 
 
अगर लेन ( x_range ) == 0 : 
वापसी 
 
X1, x2 = x_range 
y1, y2 = y_range 
 
gc के साथ : 
जी सी । set_alpha ( 0.8 ) 
जी सी । set_fill_color ( 1.0 , 1.0 , 1.0 ) ) 
जी सी । रेक्ट ( X1, y1, x2-X1, y2-y1 ) 
जी सी । draw_path ( ) 
 
pts = self ._get_selected_point ( ) 
अगर लेन ( पीटीएस ) == 0 : 
वापसी 
screen_pts = स्व । घटक । map_screen ( pts ) 
अगर hasattr ( gc , 'draw_marker_at_point' ) : 
जी सी । draw_marker_at_point ( screen_pts, 3 , DOT_MARKER ) 
और : 
जी सी । save_state ( ) 
sx के लिए, स्क्रीन_स में sy: 
जी सी । Translate_ctm ( sx, sy ) 
जी सी । start_path ( ) 
स्व । मार्कर । add_to_path ( gc , 3 ) 
जी सी । draw_path ( स्व । मार्कर । draw_mode ) 
जी सी । Translate_ctm ( -sx, -sy ) 
जी सी । rest_state ( ) 
 
def _get_selected_point ( self ) : 
"" "डेटा स्रोत में परिभाषित सीमा के भीतर सभी बिंदुओं को प्राप्त करता है 
मेटाडाटा 
"" " 
index_datasource = स्व । घटक । सूचकांक 
index_selection = index_datasource। मेटाडेटा [ 'चयन' ' 
index = index_datasource get_data ( ) 
 
value_datasource = स्व । घटक । मान 
value_selection = value_datasource। मेटाडेटा [ 'चयन' ' 
value = value_datasource। get_data ( ) 
 
x_indices = numpy। जहाँ ( ( index > index_selection [ 0 ] ) & ( index < index_selection [ - 1 ] ) ) / br>
y_indices = numpy। जहाँ ( ( मान > value_selection [ 0 ] ) & ( value < value_selection [ - 1 ] ) ) / br>
 
सूचकांक = सूची ( सेट ( x_indices [ 0 ] ) और सेट ( y_indices [ 0 ] ) ) 
 
sel_index = index [ सूचकांक ] 
sel_value = मूल्य [ सूचकांक ] 
 
रिटर्न जिप ( sel_index, sel_value ) 
 
def _get_selection_index_screen_range ( स्वयं ) : 
"" "चयनित सीमा को मैप करता है जो टूल द्वारा स्क्रीन में सेट किए गए थे
अंतरिक्ष। स्क्रीन स्पेस पॉइंट का उपयोग ओवरले ड्राइंग के लिए किया जा सकता है
"" " 
index_datasource = स्व । घटक । सूचकांक 
index_mapper = स्व । घटक । index_mapper 
index_selection = index_datasource। मेटाडेटा [ 'चयन' ' 
वापसी ट्यूपल ( index_mapper। map_screen ( numpy। सरणी ( index_selection ) ) ) 
 
def _get_selection_value_screen_range ( स्वयं ) : 
"" "चयनित सीमा को मैप करता है जो टूल द्वारा स्क्रीन में सेट किए गए थे
अंतरिक्ष। स्क्रीन स्पेस पॉइंट का उपयोग ओवरले ड्राइंग के लिए किया जा सकता है
"" " 
value_datasource = स्व । घटक । मान 
value_mapper = स्व । घटक । value_mapper 
value_selection = value_datasource। मेटाडेटा [ 'चयन' ' 
वापसी ट्यूपल ( value_mapper। map_screen ( numpy। सरणी ( value_selection ) ) ) 
 
वर्ग प्लॉटएक्सप्लिमेंट ( HasTraits ) : 
 
प्लॉट = इंस्टेंस ( प्लॉट ) 
 
traits_view = दृश्य ( आइटम ( 'प्लॉट' , संपादक = ComponentEditor ( ) ) , 
चौड़ाई = 600 , ऊंचाई = 600 ) 
 
def __init__ ( स्व , सूचकांक, मूल्य, * आर्ग, ** kw ) : 
सुपर ( प्लॉटएक्सप्लिमेंटिंग, सेल्फ ) । __in__ ( * आर्ग्स, ** kw ) 
 
plot_data = ArrayPlotData ( index = index ) 
plot_data। set_data ( 'मान' , मान ) 
 
स्व । प्लॉट = प्लॉट ( प्लॉट_डाटा ) 
पंक्ति = स्व । प्लॉट । प्लॉट ( 'इंडेक्स' , 'वैल्यू' ) ) [ 0 ] 
 
लाइन। ओवरले । परिशिष्ट ( XRayOverlay ( लाइन ) ) 
लाइन। उपकरण । परिशिष्ट ( BoxSelectTool ( लाइन ) ) 
 
सूचकांक = सुन्न। अरेंज ( 0 , 25 , 0.25 ) 
मूल्य = सुन्न। sin ( index ) + numpy। अरेंज ( 0 , 10 , 0.1 ) 
 
उदाहरण = PlotExample ( इंडेक्स, मान ) 
उदाहरण। config_traits ( )
हाइलाइटिंग के साथ विभिन्न मार्कर:

numpy से arange, सॉर्ट, कॉम्प्रेस, arange में आयात करें 
सुन्न से। यादृच्छिक आयात यादृच्छिक 
सक्षम से। example_support आयात DemoFrame, Demo_main 
सक्षम से। एपीआई आयात घटक, घटक संधारित्र, विंडो 
लक्षणों से। एपीआई आयात हैट्रेट्स, इंस्टेंस 
ट्रिटीसुई से। एपीआई आयात आइटम, समूह, देखें 
चाको से। एपीआई आयात AbstractDataSource, ArrayPlotData, प्लॉट, \ 
HPlotContainer, LassoOverlay 
चाको से। उपकरण । एपीआई आयात LassoSelection, ScatterInspector 
 
# ==================================================== ================================ 
# # चाको की साजिश रचें। 
# ==================================================== ================================ 
def _create_plot_component ( ) : 
 
# कुछ डेटा बनाएं 
npts = 2000 
x = सॉर्ट ( यादृच्छिक ( npts ) ) 
y = यादृच्छिक ( npts ) 
 
# एक भूखंड डेटा अवरोध बनाएँ और इसे यह डेटा दें 
pd = ArrayPlotData ( ) 
पीडी। set_data ( "इंडेक्स" , x ) 
पीडी। set_data ( "मान" , y ) 
 
# प्लॉट बनाएं 
प्लॉट = प्लॉट ( पीडी ) 
साजिश। प्लॉट ( "इंडेक्स" , "मूल्य" ) , 
टाइप = "स्कैटर" , 
नाम = "my_plot" , 
मार्कर = "सर्कल" , 
index_sort = "आरोही" , 
रंग = "लाल" , 
मार्कर_साइज़ = 4 , 
bgcolor = "व्हाइट" ) 
 
# कथानक के कुछ गुणों को मोड़ दें 
साजिश। शीर्षक = "चयन के साथ स्कैटर प्लॉट" 
साजिश। लाइन_अवक्रमण = 1 
साजिश। गद्दी = 50 
 
# अभी, कुछ उपकरण थोड़े आक्रामक हैं, और हमें की आवश्यकता है
# वास्तविक स्कैटरप्लॉट ऑब्जेक्ट उन्हें देने के लिए 
my_plot = कथानक। भूखंड [ "my_plot" ] [ 0 ] 
 
# भूखंड के लिए कुछ उपकरण संलग्न करें 
lasso_selection = LassoSelection ( घटक = my_plot, 
चयन_दत्तास्रोत = my_plot। सूचकांक ) 
my_plot। active_tool = lasso_selection 
my_plot। उपकरण । परिशिष्ट ( ScatterInspector ( my_plot ) ) 
lasso_overlay = LassoOverlay ( lasso_selection = lasso_selection, 
घटक = my_plot ) 
my_plot। ओवरले । append ( lasso_overlay ) 
 
# अगर आप वृद्धिशील अपडेट देखना चाहते हैं तो इसे रद्द करें: 
# lasso_selection.incremental_select = True 
 
वापसी प्लॉट 
 
 
# ==================================================== ================================ 
# प्लॉट दृश्य के लिए उपयोग करने के लिए विशेषताएँ। 
आकार = ( 650 , 650 ) 
शीर्षक = "चयन के साथ स्कैटर प्लॉट" 
bg_color = " lightgray " 
 
# ==================================================== ================================ 
# # डेमो क्लास जिसका उपयोग डेमोक्रोम एप्लिकेशन द्वारा किया जाता है। 
# ==================================================== ================================ 
वर्ग डेमो ( HasTraits ) : 
प्लॉट = इंस्टेंस ( घटक ) 
 
traits_view = दृश्य ( )
समूह ( 
आइटम ( 'प्लॉट' , संपादक = कंपोनेंट एडिटर ( आकार = आकार ) , 
show_label = गलत ) , 
ओरिएंटेशन = "वर्टिकल" ) , 
resizable = true , शीर्षक = शीर्षक 
) 
 
def _selection_changed ( self ) : 
मुखौटा = स्व । index_datasource। मेटाडेटा [ 'चयन' ] 
"नया चयन:" प्रिंट करें
प्रिंट कंप्रेस ( मास्क, अरेंज ( लेन ( मास्क ) ) ) 
 प्रिंट करें
 
def _plot_default ( self ) : 
प्लॉट = _create_plot_component ( ) 
 
# LassoSelection टूल से जुड़े प्लॉट को पुनः प्राप्त करें। 
my_plot = कथानक। भूखंड [ "my_plot" ] [ 0 ] 
lasso_selection = my_plot। सक्रिय_टूल 
 
# चयन के लिए विशेषता हैंडलर सेट करें 
स्व । index_datasource = my_plot सूचकांक 
lasso_selection। on_trait_change ( self ._selection_changed, 
'Selection_changed' ) 
 
वापसी प्लॉट 
 
डेमो = डेमो ( ) 
 
# ==================================================== ================================ 
# प्लॉट प्रदर्शित करने के लिए स्टैंड-अलोन फ्रेम। 
# ==================================================== ================================ 
वर्ग प्लॉटफ़्रेम ( डेमोफ्रेम ) : 
 
index_datasource = इंस्टेंस ( AbstractDataSource ) 
 
def _create_window ( स्व ) : 
 
घटक = _create_plot_component ( ) 
 
# LassoSelection टूल से जुड़े प्लॉट को पुनः प्राप्त करें। 
my_plot = घटक। भूखंड [ "my_plot" ] [ 0 ] 
lasso_selection = my_plot। सक्रिय_टूल 
 
# चयन के लिए विशेषता हैंडलर सेट करें 
स्व । index_datasource = my_plot सूचकांक 
lasso_selection। on_trait_change ( self ._selection_changed, 
'Selection_changed' ) 
 
# हमारे भूखंडों वाली एक खिड़की लौटें 
वापसी खिड़की ( स्वयं , - 1 , घटक = घटक, bg_color = bg_color ) 
 
def _selection_changed ( self ) : 
मुखौटा = स्व । index_datasource। मेटाडेटा [ 'चयन' ] 
"नया चयन:" प्रिंट करें
प्रिंट कंप्रेस ( मास्क, अरेंज ( लेन ( मास्क ) ) ) 
 प्रिंट करें
 
 
अगर __name__ == "__main__" : 
Demo_main ( प्लॉटफ़्रेम, आकार = आकार, शीर्षक = शीर्षक )

यह देखने के लिए कि चाको एनीमेशन कैसे लागू करता है, ईटीएस / चाको / उदाहरण / update_plot फ़ोल्डर में देखें

HPGL-GUI पर चाको

HPGL-GUI को हिस्टोग्राम बनाने की जरूरत थी। माटप्लोटलिब और चाको इसके लिए समान रूप से उपयुक्त थे। चुनाव चाको पर गिर गया, क्योंकि Matplotlib ने PySide में एकीकरण का समर्थन नहीं किया।
आँकड़ों की खिड़की इस तरह दिखती है:

यहाँ कोड पाया जा सकता है:
raw.github.com/Snegovikufa/HPGL-GUI/master/gui_widgets/statistics_window.py

PS अगर आपको PyQt4 या PySide में एम्बेड करने के बारे में बात करनी है, तो मैं इसे जोड़ूंगा।

युपीडी। वित्तीय चार्ट का एक उदाहरण अपडेट किया गया: विस्तृत टिप्पणियां जोड़ी गईं और PySide विजेट में एम्बेडिंग की गई।

चाको में ड्राइंग चार्ट

स्थापना

उदाहरण

वित्तीय:

ग्राफ़ के लिए रंगों का चयन (मैं एनीमेशन लागू करूँगा, लेकिन वास्तव में, माउस स्क्रॉल के अनुसार सब कुछ बदल जाता है):

ध्रुवीय निर्देशांक में रेखांकन:

विभिन्न बहुभुज:

एक्स-रे:

हाइलाइटिंग के साथ विभिन्न मार्कर:

यह देखने के लिए कि चाको एनीमेशन कैसे लागू करता है, ईटीएस / चाको / उदाहरण / update_plot फ़ोल्डर में देखें

HPGL-GUI पर चाको

More articles: