Matplotlib 2.1

path




matplotlib

matplotlib.path

Matplotlib भर में इस्तेमाल polylines से निपटने के लिए एक मॉड्यूल।

Matplotlib में पॉलीलाइन हैंडलिंग के लिए प्राथमिक वर्ग Path । लगभग सभी वेक्टर ड्राइंग ड्राइंग पाइपलाइन में कहीं पथों का उपयोग करता है।

जबकि Path स्वयं नहीं खींचा जा सकता है, वहां Artist उप-वर्ग मौजूद हैं जिनका उपयोग सुविधाजनक पथ विज़ुअलाइज़ेशन के लिए किया जा सकता है - इनमें से दो सबसे अधिक उपयोग PathPatch और PathCollection

class matplotlib.path.Path(vertices, codes=None, _interpolation_steps=1, closed=False, readonly=False)

आधार: object

Path संभावित रूप से डिस्कनेक्ट, संभावित रूप से बंद, रेखा और वक्र खंडों की एक श्रृंखला का प्रतिनिधित्व करता है।

अंतर्निहित भंडारण दो समांतर numpy arrays से बना है:
  • शिखर: शिखर के एनएक्स 2 फ्लोट सरणी
  • कोड : वर्टेक्स प्रकारों की एक एन-लंबाई uint8 सरणी

इन दो सरणीओं में हमेशा पहले आयाम में समान लंबाई होती है। उदाहरण के लिए, एक क्यूबिक वक्र का प्रतिनिधित्व करने के लिए, आपको तीन CURVE3 साथ-साथ तीन कोड CURVE3 प्रदान करना होगा।

कोड प्रकार हैं:

  • STOP : 1 vertex (ignored)
    पूरे पथ के अंत के लिए एक मार्कर (वर्तमान में आवश्यक नहीं है और अनदेखा किया गया है)
  • MOVETO : 1 vertex
    कलम उठाओ और दिए गए कशेरुक पर ले जाएं।
  • LINETO : 1 vertex
    वर्तमान स्थिति से दिए गए वर्टेक्स तक एक रेखा बनाएं।
  • CURVE3 : 1 control point, 1 endpoint
    दिए गए अंत बिंदु पर दिए गए नियंत्रण बिंदु के साथ वर्तमान स्थिति से एक वर्गिक बेजियर वक्र बनाएं।
  • CURVE4 : 2 control points, 1 endpoint
    दिए गए अंत बिंदु पर दिए गए नियंत्रण बिंदुओं के साथ वर्तमान स्थिति से एक घन बेजियर वक्र बनाएं।
  • CLOSEPOLY : 1 vertex (ignored)
    वर्तमान पॉलीलाइन के प्रारंभ बिंदु पर एक रेखा खंड बनाएं।

पथ वस्तुओं के उपयोगकर्ताओं को सीधे शिखर और कोड सरणी तक नहीं पहुंचना चाहिए। इसके बजाय, उन्हें vertex / code जोड़े प्राप्त करने के लिए iter_segments() या iter_segments() उपयोग करना चाहिए। यह महत्वपूर्ण है, क्योंकि ऑप्टिमाइज़ेशन के रूप में कई Path ऑब्जेक्ट्स, कोड को स्टोर नहीं करते हैं, लेकिन इसके लिए iter_segments() द्वारा प्रदान किया गया डिफ़ॉल्ट डिफॉल्ट है।

पथ वस्तुओं के कुछ व्यवहार आरसीपीराम द्वारा नियंत्रित किया जा सकता है। आरसी पैराम्स देखें जिनकी चाबियाँ 'पथ' हैं।

ध्यान दें

शिखर और कोड सरणी को अपरिवर्तनीय माना जाना चाहिए - कन्स्ट्रक्टर में सामने कई अनुकूलन और धारणाएं हैं जो डेटा बदलते समय नहीं बदलेगी।

दिए गए शिखर और कोड के साथ एक नया पथ बनाएँ।

पैरामीटर:

शिखर: array_like

पथ (n, 2) फ्लोट सरणी, मास्क किए गए सरणी या पथ के शिखर का प्रतिनिधित्व करने वाले जोड़े का अनुक्रम।

यदि शिखरों में मास्क किए गए मान होते हैं, तो उन्हें NaN में परिवर्तित कर दिया जाएगा जिन्हें तब एग्ग पाथइटरेटर और पथ डेटा के अन्य उपभोक्ताओं द्वारा सही तरीके से संभाला जाता है, जैसे iter_segments()

कोड : {कोई नहीं, array_like}, वैकल्पिक

पथ के कोड का प्रतिनिधित्व करने वाले एन-लम्बाई सरणी पूर्णांक। यदि कोई नहीं है, तो कोड समानता के समान लंबाई होना चाहिए। यदि कोई नहीं, तो कोने को लाइन सेगमेंट की श्रृंखला के रूप में माना जाएगा।

_interpolation_steps : int, वैकल्पिक

ध्रुवीय जैसे कुछ अनुमानों के संकेत के रूप में उपयोग किया जाता है, कि इस पथ को ड्राइंग से पहले रैखिक रूप से इंटरपोलेट किया जाना चाहिए। यह विशेषता प्राथमिक रूप से कार्यान्वयन विस्तार है और इसका उपयोग सार्वजनिक उपयोग के लिए नहीं है।

बंद : बूल, वैकल्पिक

यदि कोड कोई नहीं है और बंद है तो सत्य को बंद पॉलीगॉन के लाइन सेगमेंट के रूप में माना जाएगा।

केवल पढ़ने के लिए : बूल, वैकल्पिक

पथ को एक अपरिवर्तनीय तरीके से व्यवहार करता है और केवल-पढ़ने वाले सरणी के रूप में शिखर और कोड सेट करता है।

CLOSEPOLY = 79
CURVE3 = 3
CURVE4 = 4
LINETO = 2
MOVETO = 1
NUM_VERTICES_FOR_CODE = {0: 1, 1: 1, 2: 1, 3: 2, 4: 3, 79: 1}

एक शब्दकोश मैपिंग पथ कोड जो कोड की अपेक्षा करता है उस शिखर की संख्या के लिए।

STOP = 0
classmethod arc(theta1, theta2, n=None, is_wedge=False)

कोण theta1 से कोण सर्कल पर एक चाप वापस करें theta2 (डिग्री में) कोण।

theta2 360 डिग्री के भीतर सबसे छोटी चाप पैदा करने के लिए unwrapped है। यही है, अगर theta2 > theta1 + 360, आर्क theta1 से theta2 - 360 तक होगा और पूर्ण सर्कल और कुछ अतिरिक्त ओवरलैप नहीं होगा।

यदि एन प्रदान किया गया है, तो यह बनाने के लिए स्पलीन खंडों की संख्या है। यदि एन प्रदान नहीं किया गया है, तो spline खंडों की संख्या theta1 और theta2 के बीच डेल्टा के आधार पर निर्धारित की जाती है।

Masionobe, एल। 2003. polylines, वर्गिक या घन Bezier घटता का उपयोग कर एक अंडाकार चाप ड्राइंग
classmethod circle(center=(0.0, 0.0), radius=1.0, readonly=False)

दिए गए त्रिज्या और केंद्र के एक चक्र का प्रतिनिधित्व करने वाला पथ लौटाएं।

पैरामीटर:

केंद्र : फ्लोट की जोड़ी

सर्कल का केंद्र। डिफ़ॉल्ट (0, 0)

त्रिज्या : फ्लोट

सर्कल का त्रिज्या। डिफ़ॉल्ट 1 है।

केवल पढ़ने के लिए : बूल

पथ पथ बनाते समय बनाए गए पथ में "केवल पढ़ने योग्य" तर्क होना चाहिए या नहीं।

टिप्पणियाँ

सर्कल को क्यूबिक बेजियर वक्र का उपयोग करके अनुमानित किया जाता है। यह यहां प्रस्तुत दृष्टिकोण का उपयोग कर सर्कल के चारों ओर 8 splines का उपयोग करता है:

लंकास्टर, डॉन। चार बेझीर क्यूबिक स्प्लिंस का उपयोग करके सर्किल या एलीप्स का अनुमान लगाना
cleaned(transform=None, remove_nans=False, clip=None, quantize=False, simplify=False, curves=False, stroke_width=1.0, snap=False, sketch=None)

एक नया पथ उदाहरण लौटने वाले पैरामीटर के अनुसार पथ को साफ करता है।

यह भी देखें

कीवर्ड तर्कों के विवरण के लिए iter_segments() देखें।

यह दिखाता है: साफ़ किए गए शिखर और कोड के साथ पथ उदाहरण।
clip_to_bbox(bbox, inside=True)

दिए गए बाउंडिंग बॉक्स के पथ को क्लिप करें।

पथ एक या अधिक बंद बहुभुज से बना होना चाहिए। यह एल्गोरिदम अनजान पथों के लिए सही तरीके से व्यवहार नहीं करेगा।

यदि अंदर True , तो बॉक्स के अंदर, अन्यथा बॉक्स के बाहर के लिए क्लिप करें।

code_type

uint8 उपनाम

codes

1-डी numpy सरणी के रूप में Path में कोड की सूची। प्रत्येक कोड STOP , MOVETO , LINETO , CURVE3 , CURVE4 या CLOSEPOLY । उन कोडों के लिए जो एक से अधिक वर्टेक्स ( CURVE3 और CURVE4 ) से CURVE4 , वह कोड दोहराया जाएगा ताकि self.vertices और self.codes की लंबाई हमेशा समान हो।

contains_path(path, transform=None)

यह लौटाता है कि यह (बंद) पथ पूरी तरह से दिया गया पथ है या नहीं।

यदि परिवर्तन कोई None , तो परीक्षण करने से पहले पथ बदल दिया जाएगा।

contains_point(point, transform=None, radius=0.0)

लौटाता है कि (बंद) पथ में दिया गया बिंदु है या नहीं।

यदि परिवर्तन कोई None , तो परीक्षण करने से पहले पथ बदल दिया जाएगा।

त्रिज्या पथ को थोड़ा बड़ा या छोटा बनाने की अनुमति देता है।

contains_points(points, transform=None, radius=0.0)

एक बूल सरणी देता है जो True यदि (बंद) पथ में संबंधित बिंदु होता है।

यदि परिवर्तन कोई None , तो परीक्षण करने से पहले पथ बदल दिया जाएगा।

त्रिज्या पथ को थोड़ा बड़ा या छोटा बनाने की अनुमति देता है।

copy()

Path की एक उथली प्रतिलिपि देता है, जो स्रोत Path साथ शिखर और कोड साझा करेगा।

deepcopy(memo=None)

Path की एक गहरी प्रतिलिपि देता है। Path पाठक नहीं होगा, भले ही स्रोत Path है।

get_extents(transform=None)

पथ के विस्तार ( xmin , ymin , xmax , ymax ) देता है।

अकेले शिखर पर एक्सेंट्स की गणना करने के विपरीत, यह एल्गोरिदम वक्र को ध्यान में रखेगा और नियंत्रण बिंदुओं के साथ उचित तरीके से निपटेंगे।

has_nonfinite

True अगर शिखर सरणी में असीमित मान हैं।

classmethod hatch(hatchpattern, density=6)

एक हैच विनिर्देशक, हैचपर्टर्न को देखते हुए, एक पथ उत्पन्न करता है जिसे दोहराए गए हैंचिंग पैटर्न में उपयोग किया जा सकता है। घनत्व प्रति यूनिट वर्ग की लाइनों की संख्या है।

interpolated(steps)

लंबाई एन एक्स चरणों के लिए resampled एक नया रास्ता देता है। वर्तमान में interpolating घटता संभाल नहीं है।

intersects_bbox(bbox, filled=True)

यह पथ सही है यदि यह पथ किसी दिए गए Bbox को Bbox

भरे , जब सही हो, पथ का व्यवहार करता है जैसे कि यह भरा हुआ था। यही है, अगर पथ पूरी तरह से बाउंडिंग बॉक्स संलग्न करता है, intersects_bbox() सत्य वापस आ जाएगा।

बाउंडिंग बॉक्स हमेशा भरा माना जाता है।

intersects_path(other, filled=True)

यह पथ सही है यदि यह पथ किसी अन्य दिए गए पथ को छेड़छाड़ करता है।

भरे , जब सही हो, पथों का व्यवहार करता है जैसे कि वे भरे गए थे। यही है, अगर एक पथ दूसरे को पूरी तरह से घेरता है, intersects_path() सत्य वापस आ जाएगा।

iter_segments(transform=None, remove_nans=True, clip=None, snap=False, stroke_width=1.0, simplify=None, curves=True, sketch=None)

पथ में सभी वक्र खंडों पर Iterates। प्रत्येक पुनरावृत्ति 2-ट्यूपल ( शिखर , कोड ) देता है, जहां चरम 1 - 3 समन्वय जोड़े का अनुक्रम होता है, और कोड Path कोडों में से एक है।

इसके अतिरिक्त, यह विधि पथ पर कई मानक सफाई और रूपांतरण प्रदान कर सकती है।

पैरामीटर:

परिवर्तन : कोई नहीं या Transform उदाहरण

यदि कोई नहीं, तो दिए गए affine परिवर्तन पथ पर लागू किया जाएगा।

remove_nans : {गलत, सही}, वैकल्पिक

यदि सही है, तो पथ से सभी NaNs को हटा दें और उन पर छोड़ने के लिए MOVETO आदेश डालें।

क्लिप : कोई नहीं या अनुक्रम, वैकल्पिक

यदि कोई नहीं है, तो पथ को क्लिप करने के लिए एक आयत को परिभाषित करने वाला चार-ट्यूपल (x1, y1, x2, y2) होना चाहिए।

स्नैप : कोई नहीं या बूल, वैकल्पिक

अगर कोई नहीं, रेक्टिलिनर लाइनों की अस्पष्टता को कम करने के लिए पिक्सेल को स्वत: स्नैप करें। यदि सही है, तो बल खींचना, और यदि गलत है, तो स्नैप न करें।

स्ट्रोक_विड्थ : फ्लोट, वैकल्पिक

स्ट्रोक की चौड़ाई खींची जा रही है। जरूरत है

स्नैपिंग एल्गोरिदम के लिए एक संकेत के रूप में।

सरल बनाना : कोई नहीं या बूल, वैकल्पिक

यदि सही है, तो निकालने के लिए सरलीकरण करें

शिखर जो पथ की उपस्थिति को प्रभावित नहीं करते हैं। यदि गलत है, तो कोई सरलीकरण नहीं करें। यदि कोई नहीं है, तो q_simplify सदस्य चर का उपयोग करें। RcParams path.simplify और path.simplify_threshold भी देखें।

वक्र : {सही, गलत}, वैकल्पिक

यदि सही है, वक्र खंडों को वक्र खंडों के रूप में वापस कर दिया जाएगा। यदि गलत है, तो सभी घटता रेखा खंडों में परिवर्तित हो जाएंगी।

स्केच : कोई नहीं या अनुक्रम, वैकल्पिक

यदि कोई नहीं है, तो स्केच पैरामीटर का प्रतिनिधित्व करने वाले फॉर्म (स्केल, लम्बाई, यादृच्छिकता) का 3-टुपल होना चाहिए।

classmethod make_compound_path(*args)

पथ वस्तुओं की सूची से एक यौगिक पथ बनाओ।

classmethod make_compound_path_from_polys(XY)

बराबर संख्याओं के साथ कई बहुभुजों को आकर्षित करने के लिए एक यौगिक पथ ऑब्जेक्ट बनाएं XY एक (numpolys x numsides x 2) कोष्ठक की numpy सरणी है। वापसी वस्तु एक Path

( स्रोत कोड , png , pdf )

../_images/histogram_path.png
readonly

True है कि Path केवल पढ़ने के लिए है।

should_simplify

True अगर शिखर सरणी सरलीकृत किया जाना चाहिए।

simplify_threshold

एक पिक्सेल अंतर का अंश जिसके नीचे शिखर को सरलीकृत किया जाएगा।

to_polygons(transform=None, width=0, height=0, closed_only=True)

इस पथ को बहुभुज या polylines की सूची में कनवर्ट करें। प्रत्येक बहुभुज / पॉलीलाइन एक एनएक्स 2 सरणी है। दूसरे शब्दों में, प्रत्येक बहुभुज में कोई MOVETO निर्देश या वक्र नहीं है। यह बैकएंड में प्रदर्शित करने के लिए उपयोगी है जो जीडीके जैसे कंपाउंड पथ या बेजियर वक्र का समर्थन नहीं करते हैं।

यदि चौड़ाई और ऊंचाई दोनों गैर-शून्य हैं तो लाइनों को सरलीकृत किया जाएगा ताकि (0, 0), (चौड़ाई, ऊंचाई) के बाहर के शिखर को बंद कर दिया जाएगा।

अगर बंद_ऑनली True (डिफ़ॉल्ट), केवल बंद पॉलीगॉन, अंतिम बिंदु के साथ अंतिम बिंदु के समान ही वापस किया जाएगा। पथ में किसी भी संलग्न रोशनी को स्पष्ट रूप से बंद कर दिया जाएगा। यदि बंद_ऑनली False , तो पथ में किसी भी संलग्न बहुभुज को अन्तर्निहित बहुभुज के रूप में वापस कर दिया जाएगा, और बंद पॉलीगोन को अंतिम बिंदु के रूप में अंतिम बिंदु को सेट करके स्पष्ट रूप से बंद कर दिया जाएगा।

transformed(transform)

पथ की एक प्रतिलिपि प्रतिलिपि वापस करें।

यह भी देखें

matplotlib.transforms.TransformedPath
एक विशेष पथ वर्ग जो परिवर्तनित परिणाम को कैश करेगा और जब परिवर्तन बदलता है तो स्वचालित रूप से अपडेट हो जाएगा।
classmethod unit_circle()

यूनिट सर्कल के पाठक Path को वापस करें।

ज्यादातर मामलों के लिए, Path.circle() आप जो चाहते हैं वह होगा।

classmethod unit_circle_righthalf()

यूनिट सर्कल के दाहिने आधे हिस्से का Path लौटें। सर्कल को क्यूबिक बेजियर वक्र का उपयोग करके अनुमानित किया जाता है। यह यहां प्रस्तुत दृष्टिकोण का उपयोग कर सर्कल के चारों ओर 4 splines का उपयोग करता है:

लंकास्टर, डॉन। चार बेझीर क्यूबिक स्प्लिंस का उपयोग करके सर्किल या एलीप्स का अनुमान लगाना
classmethod unit_rectangle()

यूनिट आयत का Path उदाहरण (0, 0) से (1, 1) तक लौटाएं।

classmethod unit_regular_asterisk(numVertices)

दिए गए numVertices और 1.0 के त्रिज्या के साथ एक इकाई नियमित तारांकन के लिए एक Path वापस करें, (0, 0) पर केंद्रित।

classmethod unit_regular_polygon(numVertices)

दिए गए numVertices और 1.0 के त्रिज्या के साथ एक यूनिट नियमित बहुभुज के लिए Path लौटाएं, (0, 0) पर केंद्रित।

classmethod unit_regular_star(numVertices, innerCircle=0.5)

दिए गए numVertices और 1.0 के त्रिज्या के साथ एक यूनिट नियमित स्टार के लिए Path लौटें, (0, 0) पर केंद्रित।

vertices

Path में एनएक्स 2 numpy सरणी के रूप में पार्स की सूची।

classmethod wedge(theta1, theta2, n=None)

कोण theta1 से कोण सर्कल का एक वेज वापस theta2 (डिग्री में) कोण पर लौटें

थीटा 2 360 डिग्री के भीतर सबसे छोटी वेज का उत्पादन करने के लिए तैयार नहीं है। यही है, अगर theta2 > theta1 + 360, wedge theta1 से theta2 - 360 तक होगा और पूर्ण सर्कल और कुछ अतिरिक्त ओवरलैप नहीं होगा।

यदि एन प्रदान किया गया है, तो यह बनाने के लिए स्पलीन खंडों की संख्या है। यदि एन प्रदान नहीं किया गया है, तो spline खंडों की संख्या theta1 और theta2 के बीच डेल्टा के आधार पर निर्धारित की जाती है।

matplotlib.path.get_path_collection_extents(master_transform, paths, transforms, offsets, offset_transform)

Path ऑब्जेक्ट्स के अनुक्रम को देखते हुए, PathCollection में पाए गए ऑब्जेक्ट्स और ऑफसेट्स को Transform करें, बाउंडिंग बॉक्स लौटाता है जो उन सभी को encapsulates देता है।

master_transform सभी पथों पर लागू करने के लिए एक वैश्विक परिवर्तन है

पथ Path उदाहरणों का एक अनुक्रम है।

ट्रांसफॉर्म Affine2D उदाहरणों का एक अनुक्रम है।

ऑफ़सेट्स (x, y) ऑफ़सेट (या एक Nx2 सरणी) का एक अनुक्रम है

offset_transform पथ पर ऑफसेट लागू करने से पहले ऑफ़सेट पर लागू करने के लिए एक Affine2D है।

जिस तरह से पथ , रूपांतरित और ऑफसेट संयुक्त होते हैं, वैसे ही संग्रह के समान तरीके होते हैं। प्रत्येक स्वतंत्र रूप से फिर से शुरू होता है, इसलिए यदि आपके पास 3 पथ, 2 ट्रांसफॉर्म और 1 ऑफसेट हैं, तो उनके संयोजन निम्नानुसार हैं:

(ए, ए, ए), (बी, बी, ए), (सी, ए, ए)
matplotlib.path.get_paths_extents(paths, transforms=[])

Path ऑब्जेक्ट्स और वैकल्पिक Transform ऑब्जेक्ट्स के अनुक्रम को देखते हुए, बाउंडिंग बॉक्स लौटाता है जो उन सभी को encapsulates करता है।

पथ Path उदाहरणों का एक अनुक्रम है।

ट्रांसफॉर्म प्रत्येक पथ पर लागू करने के लिए Affine2D उदाहरणों का एक वैकल्पिक अनुक्रम है।