pЪ __text__TEXT_|__gcc_except_tab__TEXT_c__StaticInit__TEXTaHehH__bss__DATAЪ__data__DATA@dg__cstring__TEXTk.n__mod_init_func__DATAP __compact_unwind__LDXX__eh_frame__TEXT  h2    PKKOkUH]Hf.UHH=H5HjH uHH=H]ÐUH]fDUHSPHH=H5HbjH uHH=H5.jHHt H tH[]H=H[]fPDUHAVSH0HuHkHEЋFEHEHEH}ȃuoHutqH]H=iHAt1H=HtH=Ht HLcHuL1H0[A^]f.@UHAWAVSH(HuHkHED~D}HG]ԉ]؅yHHLw(HEMA)AuhHuH}}L}tlH=~hLAtbH=LtOH=Lt} rK,H9srJ+I9si1HHLLHtA  HHuHfDA  ALLALLALLHI9uDHpHHH‰уH`s1hHH)1AALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpHHuHt$HHADA D H HuL9}UDEtH}LLH}HLL}~A1fDAA.uzHH9xuHuH}1LHM}~D1f.DA : u HI9uHuH}LHMHtLE1H}HEH9t HtHXH`H9t HtLHĈ[A\A]A^A_]L-IEH}HEH9uHH}HEH9tHt HHXH`H9t HtH DUHAWAVAUATSHHuH&fHEFEHGMMyHHHG(HELeE1L1ÍHcHXLXH]HcILELÍHcH}LeHHcLE1HEЅIDEH}NE+ErH}%H}LHU H}HuEM9}H}LHUEM9}H}HuHEȉDž}rII9II91HHHHHtA4A4HHuH3fDA A ALALALALAL AL ALALALALALALALALHH9u1HpHHH‰уHs1pHH)1AALAALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpH HuHt*HHADA ADA H HuH9HxHEAŅ>} rK,H9srJ+I9si1HHLLHtA  HHuHfDA  ALLALLALLHI9uDHpHHH‰уH`s1hHH)1AALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpHHuHt$HHADA D H HuL9}UDEtH}LLH}HLL}~A1fDAA.uzHH9xuHuH}1LHM}~D1f.DA : u HI9uHuH}LHMHtLE1H}HEH9t HtHXH`H9t HtLHĈ[A\A]A^A_]L-IEH}HEH9uHH}HEH9tHt HHXH`H9t HtH DUHAWAVAUATSHHuHaHEFEHGMMyHHHG(HELeE1L1ÍHcHXLXH]HcILELÍHcH}LeHHcLE1HEЅIDEH}NE+ErH}%H}LHU H}HuEM9}H}LHUEM9}H}HuHEȉDž}rII9II91HHHHHtA4A4HHuH3fDA A ALALALALAL AL ALALALALALALALALHH9u1HpHHH‰уHs1pHH)1AALAALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpH HuHt*HHADA ADA H HuH9HxHEAŅ>} rK,H9srJ+I9si1HHLLHtA  HHuHfDA  ALLALLALLHI9uDHpHHH‰уH`s1hHH)1AALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpHHuHt$HHADA D H HuL9}UDEtH}LLH}HLL}~A1fDAA.uzHH9xuHuH}1LHM}~D1f.DA : u HI9uHuH}LHMHtLE1H}HEH9t HtHXH`H9t HtLHĈ[A\A]A^A_]L-IEH}HEH9uHH}HEH9tHt HHXH`H9t HtH DUHAWAVAUATSHHuH\HEFEHGMMyHHpHG(HELeLÍHcHPLPE1H]HcILELÍHcHpLpHHcLE1HEIDEH}E+ErH}\H5́H}HU}>IH}LHU#H}HuEM9}H}LHUEM9}H}HuHEHMȅ}s1HU1HUII9sII9s1ЃHpHHH‰уHs1pHH)1AALAALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpH HuHt*HHADA ADA H HuHUH9HHHHtf.fA4A4HHuHHUr]fDA A ALALALALAL AL ALALALALALALALALHH9uLHEAŅH} rK,H9s|J+I9ss1HHLLHtf.A  HHuHfDA  ALLALLALLHI9uDHxHHH‰уH`s1hHH)1AALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpHHuHt$HHADA D H HuL9}MDMtH}LMH}HLM}~A1fDAA.u z HH9EuHuH}LHM}~D1f.DA : u HI9uHuH}LHMHtRE1HpHxH9t HtHPHXH9t HtLHĈ[A\A]A^A_]L-IEHpHxH9uH HHpHxH9t HtHPHXH9t HtH UHAWAVAUATSHHuHXHEFEHGMMyHH|HG(HEEL}LAC6HcHPHPE1EIcHLELAH]C?HcHpHpIcHE1EIDEH}zIŋE+ErH}NH}Hu9H}Hu$H}HuD H}HuEM9}H}LDEM9}H}HuDHEEAs1HU1HMHUHI9sIH9s1ЃHpHHH‰уHs1H}lHH)1H}LAALD L0AD AL0D@LPAD@ALPD`LpAD`ALpH HuHt(HHD ADA H HuHUH9HHHHtH}ȋ4A4HHuH}HHUrO A LALLALL AL LALLALLALLALHH9uDHEE@A s 1HUHUIDH9sLHI9s1ЃHpHHH‰уH`s1LcHH)1LLLD L0D L0D@LPD@LPD`LpD`LpHHuHt"HHD D H HuHUH9tVHHHLHt  HHuHHUr+  LLLLLLHH9uՃ}uEDEMt $H}HMMH}HL $HMMAE~>1HMA.u z HH9EuHuH}HUDE~61AL: u HH9EuHuH}LDHtRE1HpHxH9t HtHPHXH9t HtLHĘ[A\A]A^A_]L-IEHpHxH9uHHpHxH9tHt HHPHXH9t HtH f.UHAWAVSH(HuHTHED~D}HG]ԉ]؅y HHtgLw(Mt^A)AuBHuH}tD}utHA9tAILHu6H}1H([A^A_]IL8HuHHUHAVSH HuHUHEDvDuHG]]y HHt#H(HtD9uEt%Ht*11H}111 H@HuHcHHH [A^]@UHAWAVAUATSHHHuHUHEFEHGMĉMȅyHHhL(H}11AC6HcH}LeEIcM,LDME+EăH}LDH}HuDEArII9IDI91HHHHHtDA4AtHHuHnDA ALALALALALAL AL ALALALALALALALALHH9u H}1H}HEH9kpE1؃HpHHH‰уHs1qHH)1AALADALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpH HuHt8HHf.ADA ADALH HuH9`}Ut LLILLE~B1f.AA.Du z HH9uHuH}1LDHt+1H}HEH9t HtHHH[A\A]A^A_]HHH}HEH9uHH}HEH9t HtH fUHAWAVAUATSHHHuHRHEFEHGMĉMȅyHHhL(H}11AC6HcH}LeEIcM,LDME+EăH}LDH}HuDEArII9IDI91HHHHHtDA4AtHHuHnDA ALALALALALAL AL ALALALALALALALALHH9u H}1H}HEH9kpE1؃HpHHH‰уHs1qHH)1AALADALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpH HuHt8HHf.ADA ADALH HuH9`}Ut LLILLE~B1f.AA.Du z HH9uHuH}1LDHt+1H}HEH9t HtHHH[A\A]A^A_]HHH}HEH9uHH}HEH9t HtH fUHAWAVAUATSHHHuHOHEFEHGMĉMȅyHHhL(H}11AC6HcH}LeEIcM,LDME+EăH}LDH}HuDEArII9IDI91HHHHHtDA4AtHHuHnDA ALALALALALAL AL ALALALALALALALALHH9u H}1H}HEH9kpE1؃HpHHH‰уHs1qHH)1AALADALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpH HuHt8HHf.ADA ADALH HuH9`}Ut LLILLE~B1f.AA.Du z HH9uHuH}1LDHt+1H}HEH9t HtHHH[A\A]A^A_]HHH}HEH9uHH}HEH9t HtH fUHAWAVAUATSHHuHLHEFEHGMMyHHHG(HELeE1L1ÍHcHXLXH]HcILELÍHcH}LeHHcLE1HEЅIDEH}NE+ErH}%H}LHU H}HuEM9}H}LHUEM9}H}HuHEȉDž}rII9II91HHHHHtA4A4HHuH3fDA A ALALALALAL AL ALALALALALALALALHH9u1HpHHH‰уHs1pHH)1AALAALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpH HuHt*HHADA ADA H HuH9HxHEAŅ>} rK,H9srJ+I9si1HHLLHtA  HHuHfDA  ALLALLALLHI9uDHpHHH‰уH`s1hHH)1AALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpHHuHt$HHADA D H HuL9}UDEtH}LLH}HLL}~A1fDAA.uzHH9xuHuH}1LHM}~D1f.DA : u HI9uHuH}LHMHtLE1H}HEH9t HtHXH`H9t HtLHĈ[A\A]A^A_]L-IEH}HEH9uHH}HEH9tHt HHXH`H9t HtH DUHAWAVSHHHuHGHED~D}HG]]yHHLw(MA)H}AHuH}HuH}HuH}HuH}HutzH}HutiH}HutXH}HutG}EMU]emu}t4L61HH[A^A_]E1MILHuHHf.fUHAWAVSH8HuH3HHED~D}HG]ĉ]ȅyHHLw(MA)H}AHuH}HuH}HutpH}Hut_H}HutNH}Hut=}EMU]emt4L61H8[A^A_]E1M/ILHuHHUHHHHGzu H=]H54H1]@UHHHHGzu H=]H5I1]@UHAWAVSHXHHHEHuHKHED~D}HG]]yHHLw(HEMttA)H}AuXHutZH}HuкtD(E)E}HutiHULE.Ec1H H H;MHX[A^A_]E1HEMWIHULE.Eu)z'E.EuzE.Euz E.Eu{!HuH}HUоHVHHH H H;MNfUHAWAVSHXHuHKHED~D}HG]]yHHLw(W)EHEMtcA)AuGH}HutDH}Hut3HEHE}tLHuHULNH}1Et H}HHX[A^A_]E1bIHuHUL E.Euz E.Eu{HuH}HU1HuHHEw{HEt H}H DUHAVSH@^HG)ЃgHuH-KHE]ȉỦUЅyHHHH_(H;H}Hu!HuH} H5b]H}HU}EEEE}EHuHHHuHoJHE]ȉỦUЅyHHH_(HEHtyH5\H}HUHt;IH5\H}HU}t}tUHLHHtY1H}HtHuH5I1HH@[A^]HEH HLH8HuHHH}HuH HuHH0E.Euz E.Eu{HuH}HU1H^HHQUHAWAVATSH@HuHcJHEDvDuHG]]yHHLg(MA)H}AHuкH}HuH57[H}HU}tkIH5&[H}HU}tNIH}Hut:HEHE؃}EDEt@HuLLLC1H@[A\A^A_]E1M$I$HuLLL@E.Euz E.Eu{HuH}HU1HuHHUHAWAVSH(HuH.JHED~D}HG]ԉ]؅yHHLw(MA)Au1+E1#ILHuHHH([A^A_]@UHAWAVSH(HuH)CHED~D}HG]ԉ]؅y HHt\Lw(MtSA)Au7H5LH}HU}t0}t7LHHu9H}1H([A^A_]ILHHuHHUHAVSH HuHBHEDvDuHG]]y HHt"H(HtD9uEt$Ht(1.H}111HHuHHHH [A^]UHAWAVSH(HuHgBHED~D}HG]ԉ]؅y HHt\Lw(MtSA)Au7H5~JH}HU}t0}t7LHHu9H}1H([A^A_]ILHHuHHUHAVSH HuHBHEDvDuHG]]y HHt"H(HtD9uEt$Ht(1.H}111HHuHHHH [A^]UHAVSH HuHPCHEDvDuHG]]y HHtH(HtD9uHt1H}111 HHH [A^]f.UHAVSH HuHCHEDvDuHG]]y HHtH(HtD9uHt1H}111 HHH [A^]f.UHAVSH HuHDHEDvDuHG]]y HHtH(HtD9uHt1H}111 HHH [A^]f.UHAVSH HuHCHEDvDuHG]]y HHt$H(HtD9uEt&HHt+12H}111!HPHHuHHHH [A^]fUHAWAVSH(HuHCHED~D}HG]ԉ]؅y HHt\Lw(MtSA)Au7H5yFH}HU}t0}t7LHHu9H}1H([A^A_]ILHXHuHHUHAVSH HuH#DHEDvDuHG]]y HHt H(HtD9uHHt1H}111 HHHH [A^]f.fUHAVSH HuHDHEDvDuHG]]y HHt H(HtD9uHHt1H}111 HHHH [A^]f.fUHAWAVAUATSHXHuH*HEFEHGM̉MЅyHHiL(H}E11AC6HcH}LeEIcIIDW)EHEMaE+ẼH}LDH}HuEEArKH9JI91HHLLHtfDA44HHuHMA ALLALLAL L ALLALLALLALLHI9uH}E1ERVE1DHpHHH‰уHs1hHH)1AALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpH HuHt,HH@ADA D H HuL9}tHULLIHULLE~>1fA.u z HI9uHuH}1LDHt;E1Et H}H}HEH9t HtLHX[A\A]A^A_]L-IEEuHEt H}H}HEH9t HtH fUHAWAVAUATSHXHuHK'HEFEHGM̉MЅyHHL(H}11AC6HcH}LeEIcIHEH}ME+ẼH}LDH}HuEEArKH9JI91HHLLHtf.A44HHuH}A ALLALLAL L ALLALLALLALLHI9u"H}1Et H}H}HEH9t HtHHX[A\A]A^A_]E1kDHpHHH‰уHs1hHH)1AALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpH HuHt4HHf.fADA D H HuL9K}tHULLIHULLE~>1fA.u z HI9uHuH}1LDHvHHEjnHEtH}HH}HEH9t HtH f.@UHAWAVSHhHHHEHuH$HED~D}HG]]yHHLw(W)EHEMtcA)AuGH}HutIH}Huкt3(E)E}t`HuHULbH}1Et H}HHH;EHHh[A^A_]E1NIHuHULE.Eu)z'E.EuzE.Euz E.Eu{!HuH}HUоHNHHEBFHEt H}H f.UHAWAVSHhHHHEHuH"HED~D}HG]]yHHLw(H}MtcA)AuGH}HutIH}Huкt3(E)E}toHuHULqH}1Et H}HHH;EHHh[A^A_]E1H}MUIHuHULE.Eu)z'E.EuzE.Euz E.Eu{!HuH}HUоH?HHE<.HEt H}H                 mmm   oo:o Z}}CwwZMkCUHAVSHHH=L5HLH=H5LHHHH H HHfHn HH0H4H<HDHLHHXH\HdHlHtH|HHHHHHHHHDHlHHHHHHHHHHHHHH HHHH,H$HH8HH@HDHLHTH\HdHlHt|HH[A^]llmmnnLoXooopp=rHryssvuuwwxxz zzz{{{{Z|k|~~,!ņ-:>Gۊ  (2 o{'_q֓Ε֕?O-bipwvtkOpenGLContextDevice2DvtkRenderingContextOpenGL2Python.vtkOpenGLContextDevice2DvtkOpenGLContextDevice2D - Class for drawing 2D primitives using OpenGL 1.1+. Superclass: vtkContextDevice2D This class takes care of drawing the 2D primitives for the vtkContext2D class. In general this class should not be used directly, but called by vtkContext2D which takes care of many of the higher level details. @sa vtkOpenGL2ContextDevice2D IsTypeOfV.IsTypeOf(string) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. IsAV.IsA(string) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. SafeDownCastV.SafeDownCast(vtkObjectBase) -> vtkOpenGLContextDevice2D C++: static vtkOpenGLContextDevice2D *SafeDownCast( vtkObjectBase *o) NewInstanceV.NewInstance() -> vtkOpenGLContextDevice2D C++: vtkOpenGLContextDevice2D *NewInstance() DrawPolyV.DrawPoly([float, ...], int, [int, ...], int) C++: void DrawPoly(float *f, int n, unsigned char *colors=nullptr, int nc_comps=0) override; Draw a poly line using the points - fastest code path due to memory layout of the coordinates. The line will be colored by colors array which has nc_comps components DrawLinesV.DrawLines([float, ...], int, [int, ...], int) C++: void DrawLines(float *f, int n, unsigned char *colors=nullptr, int nc_comps=0) override; Draw lines using the points - memory layout is as follows: l1p1,l1p2,l2p1,l2p2... The lines will be colored by colors array which has nc_comps components. \sa DrawPoly() DrawPointsV.DrawPoints([float, ...], int, [int, ...], int) C++: void DrawPoints(float *points, int n, unsigned char *colors=nullptr, int nc_comps=0) override; Draw a series of points - fastest code path due to memory layout of the coordinates. Points are colored by colors array which has nc_comps components DrawPointSpritesV.DrawPointSprites(vtkImageData, [float, ...], int, [int, ...], int) C++: void DrawPointSprites(vtkImageData *sprite, float *points, int n, unsigned char *colors=nullptr, int nc_comps=0) override; Draw a series of point sprites, images centred at the points supplied. The supplied vtkImageData is the sprite to be drawn, only squares will be drawn and the size is set using SetPointSize. Points are colored by colors array which has nc_comps components - this part is optional. DrawMarkersV.DrawMarkers(int, bool, [float, ...], int, [int, ...], int) C++: void DrawMarkers(int shape, bool highlight, float *points, int n, unsigned char *colors=nullptr, int nc_comps=0) override; Draw a series of markers centered at the points supplied. The shape argument controls the marker shape, and can be one of - VTK_MARKER_CROSS - VTK_MARKER_PLUS - VTK_MARKER_SQUARE - VTK_MARKER_CIRCLE - VTK_MARKER_DIAMOND \param colors is an optional array of colors. \param nc_comps is the number of components for the color. SetMaximumMarkerCacheSizeV.SetMaximumMarkerCacheSize(int) C++: virtual void SetMaximumMarkerCacheSize(int _arg) Adjust the size of the MarkerCache. This implementation generates point sprites for each mark size/shape and uses DrawPointSprites to render them. The number of cached markers can be accessed with this function. GetMaximumMarkerCacheSizeV.GetMaximumMarkerCacheSize() -> int C++: virtual int GetMaximumMarkerCacheSize() Adjust the size of the MarkerCache. This implementation generates point sprites for each mark size/shape and uses DrawPointSprites to render them. The number of cached markers can be accessed with this function. DrawQuadV.DrawQuad([float, ...], int) C++: void DrawQuad(float *points, int n) override; Draws a rectangle DrawQuadStripV.DrawQuadStrip([float, ...], int) C++: void DrawQuadStrip(float *points, int n) override; Draws a rectangle DrawPolygonV.DrawPolygon([float, ...], int) C++: void DrawPolygon(float *, int) override; Draw a polygon using the specified number of points. DrawColoredPolygonV.DrawColoredPolygon([float, ...], int, [int, ...], int) C++: void DrawColoredPolygon(float *points, int numPoints, unsigned char *colors=nullptr, int nc_comps=0) override; DrawEllipseWedgeV.DrawEllipseWedge(float, float, float, float, float, float, float, float) C++: void DrawEllipseWedge(float x, float y, float outRx, float outRy, float inRx, float inRy, float startAngle, float stopAngle) override; Draw an elliptic wedge with center at x, y, outer radii outRx, outRy, inner radii inRx, inRy between angles startAngle and stopAngle (expressed in degrees). \pre positive_outRx: outRx>=0 \pre positive_outRy: outRy>=0 \pre positive_inRx: inRx>=0 \pre positive_inRy: inRy>=0 \pre ordered_rx: inRx<=outRx \pre ordered_ry: inRy<=outRy DrawEllipticArcV.DrawEllipticArc(float, float, float, float, float, float) C++: void DrawEllipticArc(float x, float y, float rX, float rY, float startAngle, float stopAngle) override; Draw an elliptic arc with center at x,y with radii rX and rY between angles startAngle and stopAngle (expressed in degrees). \pre positive_rX: rX>=0 \pre positive_rY: rY>=0 DrawStringV.DrawString([float, ...], string) C++: void DrawString(float *point, const vtkStdString &string) override; V.DrawString([float, ...], unicode) C++: void DrawString(float *point, const vtkUnicodeString &string) override; Draw some text to the screen! ComputeStringBoundsV.ComputeStringBounds(string, [float, float, float, float]) C++: void ComputeStringBounds(const vtkStdString &string, float bounds[4]) override; V.ComputeStringBounds(unicode, [float, float, float, float]) C++: void ComputeStringBounds(const vtkUnicodeString &string, float bounds[4]) override; Compute the bounds of the supplied string. The bounds will be copied to the supplied bounds variable, the first two elements are the bottom corner of the string, and the second two elements are the width and height of the bounding box. An empty bounding box (0, 0, 0, 0) is returned for an empty string or string with only characters that cannot be rendered. NOTE: This function does not take account of the text rotation. ComputeJustifiedStringBoundsV.ComputeJustifiedStringBounds(string, [float, float, float, float]) C++: void ComputeJustifiedStringBounds(const char *string, float bounds[4]) override; Compute the bounds of the supplied string while taking into account the justification of the currently applied text property. Simple rotations (0, 90, 180, 270 degrees) are also propertly taken into account. DrawMathTextStringV.DrawMathTextString([float, float], string) C++: void DrawMathTextString(float point[2], const vtkStdString &string) override; Draw text using MathText markup for mathematical equations. See http://matplotlib.sourceforge.net/users/mathtext.html for more information. DrawImageV.DrawImage([float, float], float, vtkImageData) C++: void DrawImage(float p[2], float scale, vtkImageData *image) override; V.DrawImage(vtkRectf, vtkImageData) C++: void DrawImage(const vtkRectf &pos, vtkImageData *image) override; Draw the supplied image at the given x, y (p[0], p[1]) (bottom corner), scaled by scale (1.0 would match the image). DrawPolyDataV.DrawPolyData([float, float], float, vtkPolyData, vtkUnsignedCharArray, int) C++: void DrawPolyData(float p[2], float scale, vtkPolyData *polyData, vtkUnsignedCharArray *colors, int scalarMode) override; Draw the supplied PolyData at the given x, y (p[0], p[1]) (bottom corner), scaled by scale (1.0 would match the actual dataset). SetColor4V.SetColor4([int, int, int, int]) C++: void SetColor4(unsigned char color[4]) override; Set the color for the device using unsigned char of length 4, RGBA. SetColorV.SetColor([int, int, int]) C++: virtual void SetColor(unsigned char color[3]) Set the color for the device using unsigned char of length 3, RGB. SetTextureV.SetTexture(vtkImageData, int) C++: void SetTexture(vtkImageData *image, int properties=0) override; Set the texture for the device, it is used to fill the polygons SetPointSizeV.SetPointSize(float) C++: void SetPointSize(float size) override; Set the point size for glyphs/sprites. SetLineWidthV.SetLineWidth(float) C++: void SetLineWidth(float width) override; Set the line width for glyphs/sprites. SetLineTypeV.SetLineType(int) C++: void SetLineType(int type) override; Set the line type type (using anonymous enum in vtkPen). MultiplyMatrixV.MultiplyMatrix(vtkMatrix3x3) C++: void MultiplyMatrix(vtkMatrix3x3 *m) override; Multiply the current model view matrix by the supplied one. SetMatrixV.SetMatrix(vtkMatrix3x3) C++: void SetMatrix(vtkMatrix3x3 *m) override; Set the model view matrix for the display GetMatrixV.GetMatrix(vtkMatrix3x3) C++: void GetMatrix(vtkMatrix3x3 *m) override; Set the model view matrix for the display PushMatrixV.PushMatrix() C++: void PushMatrix() override; Push the current matrix onto the stack. PopMatrixV.PopMatrix() C++: void PopMatrix() override; Pop the current matrix off of the stack. SetClippingV.SetClipping([int, ...]) C++: void SetClipping(int *x) override; Supply an int array of length 4 with x1, y1, x2, y2 specifying clipping for the display. EnableClippingV.EnableClipping(bool) C++: void EnableClipping(bool enable) override; Disable clipping of the display. BeginV.Begin(vtkViewport) C++: void Begin(vtkViewport *viewport) override; Begin drawing, pass in the viewport to set up the view. EndV.End() C++: void End() override; End drawing, clean up the view. BufferIdModeBeginV.BufferIdModeBegin(vtkAbstractContextBufferId) C++: void BufferIdModeBegin(vtkAbstractContextBufferId *bufferId) override; Start BufferId creation Mode. The default implementation is empty. \pre not_yet: !GetBufferIdMode() \pre bufferId_exists: bufferId!=0 \post started: GetBufferIdMode() BufferIdModeEndV.BufferIdModeEnd() C++: void BufferIdModeEnd() override; Finalize BufferId creation Mode. It makes sure that the content of the bufferId passed in argument of BufferIdModeBegin() is correctly set. The default implementation is empty. \pre started: GetBufferIdMode() \post done: !GetBufferIdMode() SetStringRendererToFreeTypeV.SetStringRendererToFreeType() -> bool C++: bool SetStringRendererToFreeType() Force the use of the freetype based render strategy. If Qt is available then freetype will be used preferentially, otherwise this has no effect. Returns true on success. SetStringRendererToQtV.SetStringRendererToQt() -> bool C++: bool SetStringRendererToQt() Force the use of the Qt based string render strategy. If Qt is not available then freetype will be used and this will return false. HasGLSLV.HasGLSL() -> bool C++: bool HasGLSL() Check whether the current context device has support for GLSL. GetRenderWindowV.GetRenderWindow() -> vtkOpenGLRenderWindow C++: virtual vtkOpenGLRenderWindow *GetRenderWindow() Get the active RenderWindow of the device. Will return null if not active. ReleaseGraphicsResourcesV.ReleaseGraphicsResources(vtkWindow) C++: virtual void ReleaseGraphicsResources(vtkWindow *window) Release any graphics resources that are being consumed by this device. The parameter window could be used to determine which graphic resources to release. GetProjectionMatrixV.GetProjectionMatrix() -> vtkMatrix4x4 C++: vtkMatrix4x4 *GetProjectionMatrix() Get the projection matrix this is needed GetModelMatrixV.GetModelMatrix() -> vtkMatrix4x4 C++: vtkMatrix4x4 *GetModelMatrix() Get the projection matrix this is needed vtkContextDevice2DvtkObjectvtkObjectBasevtkImageData@Ps *f@Pu *f@sP *f@uP *fvtkRectfvtkPolyDatavtkUnsignedCharArrayvtkMatrix3x3vtkViewportvtkAbstractContextBufferIdvtkWindowA_ Op  !'a !!XA_ XA`XA$`p-XAH`%XAl`"a#!`$wXA`'wXA``+wXA`.XA`4aP6Pa7<7< 8a9{aA`P;Y!= P?&a@*aAaBaCapDa@Ea FaGaG!H!@I#XAapLaPMa0N!NaO!pP!Q!Q!PR!SaS!T! U~XA(aXXA@a0\aA\a^aApaa!zRx $_OAC $D8_ AC $l _AC B$_AC G$@`'AC I$HaAC G$ aAC G$4AC I$\`AC G$HAC I$PAC I$ؔ<AC $<AC $$AC I$LYAC G,tHAC K$&AC I$*AC I$ȝAC I$AC I$DhAC I$lAC I$AC I$pAC I$(AC I$ AC G$4hAC G$\ AC I$اAC I$AC G$AC I$ЩAC G$$XAC G$LЪAC G$tHAC G$AC G$HAC I$AC G$xAC G$<`AC CzPLRx ,$XCAC 4T(]#AC P4bAC P4xhAC P4 n-AC P44t%ӷAC P4l{wAC M4~wAC M40wAC M4x_AC P,L0{KAC I4|p#/AC M4~AC M4`AC M,$ӶAC I,TXAC I_f-_-_-_e=_Q-_|-d_Q- _-^=^-^l-^-^s-^v-e^-L^n-"^^=]f-]-]-]e=]Q-]|-]Q-]=]-]l-\-\s-\w-|\n-R\@\=\f-\-[-[e=[Q-[|-[Q-g[-kZ-TZ-CZl-gYv-RYs-+Y-Yp-Xj-Xn-XXf-X-yX-[Xe=BX-+X-XQ-X|-WQ-W-Vl-Uw-Us-Up-~Uj-`Un-8UU-Tl-TQ-T-Tn-TaT-WTl-?TQ-7T-Tn-SSe=SQ-Sl-SQ-S-lSm-_S>Sn-SR-RQ-Rl-RQ-Rn-bR0RO-&Rl-RQ-R-Qn-QQO-Ql-nQQ-gQ-LQn-"QPO-Pl-PQ-P-Pn-PUPe=IPQ-9Pl-!PQ-P-On-OOe=OQ-Ol-hOQ-cO-LOm-?OOn-NNe=NQ-Nl-NQ-N-lNn-BNNe=NQ-Ml-MQ-M-Mm-MMn-dM:Me=.MQ-Ml-LQ-L-Ly-Ln-L]Lf-UL-(Le=L-KQ-K~-KQ-K-Jl-Iu-Ir-Ij-In-XI%Ie=IQ- Il-HQ-H-Hn-HuHe=iHQ-YHl-AHQ-Gn-GFe=FQ-Fl-FQ-F-Fm-F^Fn-4FFe=FQ-El-EQ-E-Em-E~En-TE3Ee='EQ- El-DQ-D-D{-Dn-DeDe=YDQ-;Dl-!DQ-D-Dz-Cn-CCe=CQ-kCl-QCQ-LC-5Cz-Cn-BBe=BQ-BQ-B-iB{-IBm-l->->{-v>m-i>Y>m-L>=>z-(>s-=n-==e==Q-=|-o=Q-/=e=#=Q-<k-<<d-<Q-<-<m-<<o-<^<n-H<8<-;m-;;z-;s-;n-;E;f-=;-;e= ;Q-;|-:Q-:-:l-:-^:w-M:s-:n-99-9=9e=9Q-9|-}9Q-9=8l-8-8s-8x-l8n-B808=8k-88-8!7k-77-77e=7Q-_7l-N7-7z- 7z-6z-6z-6z-6z-6n-d6;6e=/6Q-6l-5-5z-5z-5z-5z-p5z-[5z-F5z-15z-4n-44f-4-4-\4e=@4-#4-4Q-3}-3Q-3|-3Q-Y3-J0{-+0t- 0{-/s-/l-/q-/j-\/p-H/j-#/n-..f-.-.e=.-f.Q-a.|-K.Q- .-,l-,{- ,s-+p-+j-+n-x+Q+f-I+-+e=+-*Q-*|-*Q-*-|)l-({-(s-P(p-=(j- (n-''f-'-'e='-f'Q-a'|-K'Q- '-%l-%{- %s-$p-$j-$n-x$I$R-<$Q-*$l-$Q-#n-##e=#Q-}#l-c#Q-5#{-#n-""f-"-"-Z"e=>"-!"-!Q-!}-!Q-!|-!Q-Y!-B{-#t-{-s-y-{-l-aq-Gj-"p- j-n-f--r-2e=--Q-}-Q-|-kQ-)-{-t-{-s-m-xl-(q-j-p-j-n-ef-]-9- e=--Q-}-Q-e|-NQ- -{-t-{-s-l-Bq-1j- p-j-n-f-}-Y-,e=--Q-}-Q-|-nQ-)- {- t- {- s- l-b q-Q j-, p- j- n-  f- -y -L e=0 - - Q- }- Q- |- Q-I -:{-t-{-s-l-q-qj-Lp-8j-n-`-\-Z--vQ-ll-VQ-B n--Q-l-Q-u]m-P2R-Q-l-i----~ex-.n-l-R-Q-i---u-m^x-2--d-P-V-c-X-v-ibV-]VOc-GAX-<5.'N-g-uj_TI>3,%S=^= ]=zohab=ZSHA:Y=3,U=%T=a=_=[=xqf_XW=MF->J7M=0h-+- =- IFxhD8(B@?>=xh<`XH;@8(: 98765xh4`XH2@8(1 0/.-,xh+`XH*@8() ('&%#xh"`XH @8( xh`XH@8(   xh`XH@8( Hxp`@ `@ `@ `@ `XP@80 xp`XP@80 `@ sM~_Eت@dp  U 9L_ `U$`CpBH` l`|"#`$ `'``+`3.`4P67@j7j? 8W92`P;S=P?@ ABBCBpD@E FGG,H@IapLPM0NsNrO{pPQQPRScST U/(anX @a0\E\a*^paaЪѪ j    ZA8) 3s   bGk< WD (oh  7 e J  "Z   <]  &X1  2    tB OAy H Ws o%5 {h_PyType_Ready__GLOBAL__sub_I_vtkOpenGLContextDevice2DPython.cxx__ZN24vtkOpenGLContextDevice2D24ReleaseGraphicsResourcesEP9vtkWindow_PyvtkContextDevice2D_ClassNew_PyvtkOpenGLContextDevice2D_ClassNew_PyVTKObject_New__ZL36PyvtkOpenGLContextDevice2D_StaticNewv__Z45vtkRenderingContextOpenGL2_AutoInit_Constructv__Z44vtkRenderingContextOpenGL2_AutoInit_Destructv__ZSt9terminatev__ZdlPv__ZdaPv__ZN24vtkOpenGLContextDevice2D9PopMatrixEv__ZN24vtkOpenGLContextDevice2D19GetProjectionMatrixEv__ZN24vtkOpenGLContextDevice2D14GetModelMatrixEv__ZN24vtkOpenGLContextDevice2D10PushMatrixEv__ZN24vtkOpenGLContextDevice2D3NewEv__ZN24vtkOpenGLContextDevice2D21SetStringRendererToQtEv__ZN24vtkOpenGLContextDevice2D27SetStringRendererToFreeTypeEv__ZN24vtkOpenGLContextDevice2D15BufferIdModeEndEv__ZN24vtkOpenGLContextDevice2D3EndEv__ZN24vtkOpenGLContextDevice2D7HasGLSLEv__ZN35vtkRenderingContextOpenGL2_AutoInitD1Ev__ZN20vtkDebugLeaksManagerD1Ev__ZN20vtkDebugLeaksManagerC1Ev__ZN16vtkUnicodeStringC1Ev__ZN24vtkOpenGLContextDevice2D5BeginEP11vtkViewport___cxa_atexit_PyVTKObject_GetSet__Py_NoneStruct__ZN13vtkPythonArgs21GetArgAsSpecialObjectEPKcPP7_object_PyVTKObject_GetObject__ZL54PyvtkOpenGLContextDevice2D_ComputeStringBounds_Methods__ZL45PyvtkOpenGLContextDevice2D_DrawString_Methods__ZL34PyvtkOpenGLContextDevice2D_Methods_PyObject_GenericSetAttr_PyObject_GenericGetAttr_PyVTKObject_Repr_PyVTKObject_AsBuffer_strcmp___stack_chk_fail_PyObject_GC_Del__ZN13vtkPythonArgs5ArrayIiEC1El__ZN13vtkPythonArgs5ArrayIhEC1El__ZN13vtkPythonArgs5ArrayIfEC1El_PyVTKObject_Check__ZN24vtkOpenGLContextDevice2D12DrawPolyDataEPffP11vtkPolyDataP20vtkUnsignedCharArrayi__ZN13vtkPythonArgs8GetArrayEPii__ZN13vtkPythonArgs8SetArrayEiPKii__ZN13vtkPythonArgs13ArgCountErrorEii__ZN24vtkOpenGLContextDevice2D11DrawMarkersEibPfiPhi__ZN24vtkOpenGLContextDevice2D16DrawPointSpritesEP12vtkImageDataPfiPhi__ZN24vtkOpenGLContextDevice2D8DrawPolyEPfiPhi__ZN24vtkOpenGLContextDevice2D10DrawPointsEPfiPhi__ZN24vtkOpenGLContextDevice2D9DrawLinesEPfiPhi__ZN24vtkOpenGLContextDevice2D18DrawColoredPolygonEPfiPhi__ZN13vtkPythonArgs8GetArrayEPhi__ZN13vtkPythonArgs8SetArrayEiPKhi__ZN13vtkPythonArgs8GetArrayEPfi__ZN24vtkOpenGLContextDevice2D13DrawQuadStripEPfi__ZN24vtkOpenGLContextDevice2D11DrawPolygonEPfi__ZN24vtkOpenGLContextDevice2D8DrawQuadEPfi__ZN13vtkPythonArgs8SetArrayEiPKfi__ZN24vtkOpenGLContextDevice2D10SetTextureEP12vtkImageDatai__ZN13vtkPythonArgs8GetValueERi__ZN24vtkOpenGLContextDevice2D11SetClippingEPi__ZN13vtkPythonArgs10GetArgSizeEi__ZN24vtkOpenGLContextDevice2D11SetLineTypeEi___cxa_begin_catch__ZN24vtkOpenGLContextDevice2D8SetColorEPh__ZN24vtkOpenGLContextDevice2D9SetColor4EPh_PyBool_FromLong_PyLong_FromLong_PyDict_SetItemString__ZN13vtkPythonArgs8GetValueER16vtkUnicodeString__ZN24vtkOpenGLContextDevice2D10DrawStringEPfRK16vtkUnicodeString__ZN24vtkOpenGLContextDevice2D10DrawStringEPfRK12vtkStdString__ZN24vtkOpenGLContextDevice2D18DrawMathTextStringEPfRK12vtkStdString_PyVTKObject_String_PyVTKObject_SetFlag__ZN24vtkOpenGLContextDevice2D16DrawEllipseWedgeEffffffff__ZN24vtkOpenGLContextDevice2D15DrawEllipticArcEffffff__ZN13vtkPythonArgs8GetValueERf__ZN24vtkOpenGLContextDevice2D19ComputeStringBoundsERK16vtkUnicodeStringPf__ZN24vtkOpenGLContextDevice2D19ComputeStringBoundsERK12vtkStdStringPf__ZN24vtkOpenGLContextDevice2D28ComputeJustifiedStringBoundsEPKcPf__ZN24vtkOpenGLContextDevice2D12SetLineWidthEf__ZN24vtkOpenGLContextDevice2D12SetPointSizeEf_PyVTKObject_Delete___clang_call_terminate_PyVTKObject_Traverse__ZN13vtkPythonUtil20GetObjectFromPointerEP13vtkObjectBase_PyType_Type__ZL31PyvtkOpenGLContextDevice2D_Type__Unwind_Resume___dso_handle__ZL28vtkDebugLeaksManagerInstance__ZL44vtkRenderingContextOpenGL2_AutoInit_Instance___stack_chk_guard_PyErr_Occurred_PyVTKClass_Add__ZN24vtkOpenGLContextDevice2D17BufferIdModeBeginEP26vtkAbstractContextBufferId__Py_Dealloc__ZN13vtkPythonArgs8GetValueERPc__ZN13vtkPythonArgs13ArgCountErrorEiPKc__ZN13vtkObjectBase8IsTypeOfEPKc__ZN13vtkPythonArgs17GetArgAsVTKObjectEPKcRb__ZN13vtkPythonArgs8GetValueERb__ZN24vtkOpenGLContextDevice2D14EnableClippingEb__ZN24vtkOpenGLContextDevice2D9DrawImageERK8vtkRectfP12vtkImageData__ZN24vtkOpenGLContextDevice2D9DrawImageEPffP12vtkImageData__ZN17vtkPythonOverload10CallMethodEP11PyMethodDefP7_objectS3___ZN13vtkPythonArgs19GetSelfFromFirstArgEP7_objectS1___ZL35PyvtkOpenGLContextDevice2D_DrawPolyP7_objectS0___ZL41PyvtkOpenGLContextDevice2D_MultiplyMatrixP7_objectS0___ZL36PyvtkOpenGLContextDevice2D_SetMatrixP7_objectS0___ZL36PyvtkOpenGLContextDevice2D_GetMatrixP7_objectS0___ZL36PyvtkOpenGLContextDevice2D_PopMatrixP7_objectS0___ZL46PyvtkOpenGLContextDevice2D_GetProjectionMatrixP7_objectS0___ZL41PyvtkOpenGLContextDevice2D_GetModelMatrixP7_objectS0___ZL37PyvtkOpenGLContextDevice2D_PushMatrixP7_objectS0___ZL42PyvtkOpenGLContextDevice2D_GetRenderWindowP7_objectS0___ZL39PyvtkOpenGLContextDevice2D_SafeDownCastP7_objectS0___ZL48PyvtkOpenGLContextDevice2D_SetStringRendererToQtP7_objectS0___ZL37PyvtkOpenGLContextDevice2D_DrawPointsP7_objectS0___ZL38PyvtkOpenGLContextDevice2D_DrawMarkersP7_objectS0___ZL43PyvtkOpenGLContextDevice2D_DrawPointSpritesP7_objectS0___ZL36PyvtkOpenGLContextDevice2D_DrawLinesP7_objectS0___ZL51PyvtkOpenGLContextDevice2D_ReleaseGraphicsResourcesP7_objectS0___ZL46PyvtkOpenGLContextDevice2D_ComputeStringBoundsP7_objectS0___ZL55PyvtkOpenGLContextDevice2D_ComputeJustifiedStringBoundsP7_objectS0___ZL35PyvtkOpenGLContextDevice2D_SetColorP7_objectS0___ZL40PyvtkOpenGLContextDevice2D_DrawQuadStripP7_objectS0___ZL38PyvtkOpenGLContextDevice2D_DrawPolygonP7_objectS0___ZL45PyvtkOpenGLContextDevice2D_DrawColoredPolygonP7_objectS0___ZL44PyvtkOpenGLContextDevice2D_BufferIdModeBeginP7_objectS0___ZL32PyvtkOpenGLContextDevice2D_BeginP7_objectS0___ZL39PyvtkOpenGLContextDevice2D_SetLineWidthP7_objectS0___ZL37PyvtkOpenGLContextDevice2D_DrawStringP7_objectS0___ZL45PyvtkOpenGLContextDevice2D_DrawMathTextStringP7_objectS0___ZL38PyvtkOpenGLContextDevice2D_SetClippingP7_objectS0___ZL41PyvtkOpenGLContextDevice2D_EnableClippingP7_objectS0___ZL35PyvtkOpenGLContextDevice2D_IsTypeOfP7_objectS0___ZL39PyvtkOpenGLContextDevice2D_SetPointSizeP7_objectS0___ZL52PyvtkOpenGLContextDevice2D_SetMaximumMarkerCacheSizeP7_objectS0___ZL52PyvtkOpenGLContextDevice2D_GetMaximumMarkerCacheSizeP7_objectS0___ZL37PyvtkOpenGLContextDevice2D_SetTextureP7_objectS0___ZL38PyvtkOpenGLContextDevice2D_SetLineTypeP7_objectS0___ZL54PyvtkOpenGLContextDevice2D_SetStringRendererToFreeTypeP7_objectS0___ZL43PyvtkOpenGLContextDevice2D_DrawEllipseWedgeP7_objectS0___ZL36PyvtkOpenGLContextDevice2D_DrawImageP7_objectS0___ZL38PyvtkOpenGLContextDevice2D_NewInstanceP7_objectS0___ZL42PyvtkOpenGLContextDevice2D_BufferIdModeEndP7_objectS0___ZL30PyvtkOpenGLContextDevice2D_EndP7_objectS0___ZL35PyvtkOpenGLContextDevice2D_DrawQuadP7_objectS0___ZL42PyvtkOpenGLContextDevice2D_DrawEllipticArcP7_objectS0___ZL39PyvtkOpenGLContextDevice2D_DrawPolyDataP7_objectS0___ZL34PyvtkOpenGLContextDevice2D_HasGLSLP7_objectS0___ZL30PyvtkOpenGLContextDevice2D_IsAP7_objectS0___ZL36PyvtkOpenGLContextDevice2D_SetColor4P7_objectS0___ZL49PyvtkOpenGLContextDevice2D_ComputeStringBounds_s2P7_objectS0___ZL40PyvtkOpenGLContextDevice2D_DrawString_s2P7_objectS0___ZL49PyvtkOpenGLContextDevice2D_ComputeStringBounds_s1P7_objectS0___ZL40PyvtkOpenGLContextDevice2D_DrawString_s1P7_objectS0___ZN13vtkPythonArgs8GetValueERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE_PyVTKAddFile_vtkOpenGLContextDevice2DGCC_except_table9GCC_except_table39GCC_except_table19GCC_except_table18GCC_except_table17GCC_except_table16GCC_except_table55GCC_except_table25GCC_except_table54__ZN24vtkOpenGLContextDevice2D14MultiplyMatrixEP12vtkMatrix3x3__ZN24vtkOpenGLContextDevice2D9SetMatrixEP12vtkMatrix3x3__ZN24vtkOpenGLContextDevice2D9GetMatrixEP12vtkMatrix3x3GCC_except_table53GCC_except_table13GCC_except_table52GCC_except_table12GCC_except_table11___gxx_personality_v0GCC_except_table0GCC_except_table10