ELF>@@+*   !"UH@dH%(HD$81HHt$HD$HFHD$$D$ t0H|$1HT$8dH+%(uhH@]@HT$H|$H5|$HtHt+HH5HPtHuH1Huff.fHXdH%(HD$H1HHt$ HD$(HFHD$4D$0t1H|$ 1HT$HdH+%(u{HXfDHt$H|$ tD$/ L$ r0D$D$HuXD$ ,HcfDT$ ff.HGI~H)ǃuHH=LHH51HÐHGI~H)ǍGwHH=L@HH51HÐHGI~H)ǃuHH=LHH51HÐUSHHdH%(HD$81HHt$HD$HFHD$$D$ HD$t6H|$1HT$8dH+%(utHH[]fHt$H|$tHl$H=HtHH=uHuHc@HH8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(u9H8HHuҐHuHHff.@H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(u9H8HHuҐHuHHff.@H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(u9H8HHuҐHuHHff.@UH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u8H0]fDHHuӐHHuHff.@SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u7H0[fDHHuӐHuUH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u8H0]fDHHuӐHHuHff.@UH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u8H0]fDHHuӐHHuHff.@UH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u8H0]fDHHuӐHHuHff.@SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u7H0[fDHHuӐHuSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u7H0[fDHHuӐHuUH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uVH0]fDHHuӐtHoHHuH@HHH;tHUH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uVH0]fDHHuӐtHo0HuH@HHH;tHUH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(u_H@]f.HHuϐH5HT$H|$|$HtHHuHHff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(uWH@]f.HHuϐHt$H|$tHt$HHuHH@UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(u_H@]f.HHuϐH5HT$H|$|$HtHHuHHff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(u_H@]f.HHuϐH5HT$H|$|$HtHHuHHff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(u_H@]f.HHuϐH5HT$H|$|$HtHHuHHff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(u_H@]f.HHuϐH5HT$H|$|$HtHHuHHff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(u_H@]f.HHuϐH5HT$H|$|$HtHHuHHff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(u_H@]f.HHuϐH5HT$H|$|$HtHHuHHff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(u_H@]f.HHuϐH5HT$H|$|$HtHHu@ff.ATUHHfnFdH%(HD$81HHt$HD$HGfnЉD$(fbfD$ uJHo(Ht!D$ +D$$tDH|$1HT$8dH+%(upHH]A\fDHHuѐLd$Ht$LtHt$ LtL$ D$HHuHHfAWAVAUATUH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ Ho(Ht!D$ +D$$t:H|$1HT$8dH+%(H@]A\A]A^A_fL|$Lt$LH5L|$ItLH5L|$ItLH5L|$HxLLHH\HHNfHH4DAVAUATUHhfnFdH%(HD$X1HHt$HD$HGfnȉD$(fbfD$ uvHo(Ld$0LHt!D$ +D$$tsH|$E1H|$0HD$@H9tHD$XdH+%(HhL]A\A]A^DHHyH|$0E1Lt$HT$H5L|$IzLLgLLHHKL%I$=HAVAUATUHhfnFdH%(HD$X1HHt$HD$HGfnȉD$(fbfD$ uvHo(Ld$0LHt!D$ +D$$tsH|$E1H|$0HD$@H9tHD$XdH+%(HhL]A\A]A^DHHyH|$0E1Lt$HT$H5L|$IzLLgLLHHKL%I$=HAUATUH`fnFdH%(HD$X1HHt$HD$HGfnȉD$(fbfD$ uxHo(Ld$0LHt!D$ +D$$tuH|$E1H|$0HD$@H9tHD$XdH+%(H`L]A\A]fHHwH|$0E1Ll$LLtHT$H5L|$HiLHHPL%I$BHff.@AVAUATUSH`fnFdH%(HD$X1HHt$HD$HGfnȉD$(fbfD$ u}Lg(H\$@D$@H\$0HD$8MtmD$ +D$$tgH|$E1H|$0H9tHD$XdH+%(H`L[]A\A]A^DHHrE1fLl$HT$H5L|$HtLt$0LLrLHLHVL%I$HHAVAUATUSH`fnFdH%(HD$X1HHt$HD$HGfnȉD$(fbfD$ u}Lg(H\$@D$@H\$0HD$8MtmD$ +D$$tgH|$E1H|$0H9tHD$XdH+%(H`L[]A\A]A^DHHrE1fLl$HT$H5L|$HtLt$0LLrLHLHVL%I$HHAUATUSHhfnFdH%(HD$X1HHt$HD$HGfnȉD$(fbfD$ uLg(H\$@D$@Hl$0H\$0HD$8MtjD$ +D$$tdH|$E1H|$0H9tHD$XdH+%(HhL[]A\A]@HHpE1fLl$HLtHT$H5L|$HzHLHaL%I$SHff.@AVAUATUSH@fnFdH%(HD$81HH4$HD$HGfnȉD$fbfD$uNHo(HtD$+D$tPH1HT$8dH+%(H@[]A\A]A^HHufLt$ ILLtH\$ LHLd$(fn.T$ zTuRH fn.D$$zCuAfAn.\$(z5u3I fAn.D$,z#u!HEHH7HuչL1Lff.fATUHHfnFdH%(HD$81HHt$HD$HGfnD$(fbfD$ uJHo(Ht!D$ +D$$tDH|$1HT$8dH+%(HH]A\fHHuѐLd$HLtHt$LtHt$LtHt$ Lt\$ T$HL$$H\HHNATUHHfnFdH%(HD$81HHt$HD$HGfnD$(fbfD$ uJHo(Ht!D$ +D$$tDH|$1HT$8dH+%(HH]A\fHHuѐLd$HLtHt$LtHt$LtHt$ Lt\$ T$HL$$H\HHNAUATUH`fnFdH%(HD$X1HHt$HD$HGfnЉD$(fbfD$ uxHo(Ld$0LHt!D$ +D$$tuH|$E1H|$0HD$@H9tHD$XdH+%(H`L]A\A]fHHwH|$0E1Ll$Ht$LtHt$ LtLLaL$ D$LHHHH0fAVAUATUHXfnFdH%(HD$H1HHt$ HD$(HGfnЉD$8fbfD$0Ho(Ht!D$0+D$4tE1fLt$ HT$H5L|$InL|$@LLVHD$`LHHD$9HL$LLLHL%I$ IATUHXfnFdH%(HD$H1HHt$ HD$(HGfnD$8fbfD$0uJHo(Ht!D$0+D$4tDH|$ 1HT$HdH+%(HX]A\fHHuѐLd$ Ht$LtHt$ LtHt$LtHt$LtHt$LrHt$L]l$d$H\$T$L$ D$H#HHff.AWAVAUATUSHhfnFdH%(HD$X1HH4$HD$HGfnȉD$fbfD$utHo(Ld$0LHtD$+D$tqHE1H|$0HD$@H9tHD$XdH+%(HhL[]A\A]A^A_fHH{H|$0E1ILLtL|$ LLrLLHH\$ Lt$(fn.T$ zVuTH fn.D$$zEuCfAn.\$(z7u5I fAn.D$,z%u#HL%I$@HuӹLLHfDATUHXfnFdH%(HD$H1HHt$ HD$(HGfnD$8fbfD$0uJHo(Ht!D$0+D$4tDH|$ 1HT$HdH+%(HX]A\fHHuѐLd$ Ht$LtHt$ LtHt$LtHt$LtHt$LrHt$L]l$d$H\$T$L$ D$H#HHff.AWAVAUATUSHxfnFdH%(HD$h1HHt$HD$HGfnȉD$(fbfD$ Ho(H\$PD$PLd$@H\$@HD$HHtjD$ +D$$tlH|$E1H|$@H9tHD$hdH+%(HxL[]A\A]A^A_HHpE1f.Lt$LLtL|$0LLwHD$8LLHLl$0HD$fAn.T$0zVuTI fAn.D$4zDuBHL$fn.\$8z2u0H fn.D$D$ +D$$H|$1fH51HT$8dH+%(HH]A\fDHD$8dH+%(HHHH=L]A\LIHQf.Ld$HLtHt$L_Ht$LJHt$ L5\$ T$HL$$HHHAV1IAUATUSHpfnFdH%(HD$hHG~H%fn)fbt;H51HT$hdH+%(WHp[]A\A]A^H Ht$ HL$(T$8fD$0HIh(Ht%D$0+D$4H|$ 1fH Ht$ HL$(T$8fD$0H,Hl$ 1Mp(1HH|$@4AHcLl$@EubM5D$0+D$4HH|$@1HT$HH9HHD$HD$@IcI\fDH5HT$H|$ |$HHHHHrfDDLHTHt$H?EIUHH)H[AD$MD1HfDATHH9uDAt@ADHHA9~"ADDA9~ ADDT$LLE~3Ic1fDHH9tAD.ztHIH|$@1MKHH;fLIHH|$ 1H|$@4HcH|$@1IL1fLIH1D1ADHH9uDL1H7HAV1IAUATUSHpfnFdH%(HD$hHG~H%fn)fbt;H51HT$hdH+%(WHp[]A\A]A^H Ht$ HL$(T$8fD$0HIh(Ht%D$0+D$4H|$ 1fH Ht$ HL$(T$8fD$0H,Hl$ 1Mp(1HH|$@4AHcLl$@EubM5D$0+D$4HH|$@1HT$HH9HHD$HD$@IcI\fDH5HT$H|$ |$HHHHHrfDDLHTHt$H?EIUHH)H[AD$MD1HfDATHH9uDAt@ADHHA9~"ADDA9~ ADDT$LLE~3Ic1fDHH9tAD.ztHIH|$@1MKHH;fLIHH|$ 1H|$@4HcH|$@1IL1fLIH1D1ADHH9uDL1H7HAV1AUATUSHĀHNdH%(HD$x1HGAfnH%fnA)fbAtA5HHt$0H\$8T$HfD$@HAHo(Ht%D$@+D$DGH|$01HT$xdH+%(H[]A\A]A^HHt$0H\$8L$@T$DT$HHHl$0Lw(11HH|$P4AHcLl$PEMD$@+D$DHH|$P1HT$XH9BH9HD$HD$%fDH5D1 f.IcI\oHHf.Ld$0Ht$LHt$LHt$LHt$LtHt$ L_Ht$$LJHt$(L5Ht$,L |$,t$(Hl$$d$ \$T$L$D$HHHDDLHZEIUHH)HEAD$7D1HATHH9uDAt@ADHHA9~"ADDA9~ ADDLLE~AIc1 fHH9t/AD.ztHuDL1HfDIH|$P1M_HHOHHH|$01H|$P4HcH|$P1IL1DD1ADHH9uHff.fAW1IAVAUATUSHfnFdH%(HD$xHG~H%fn)fbƒtN |H5E1HD$xdH+%(HĈL[]A\A]A^A_@HD$xdH+%(HĈHH=L[]A\A]A^A_fHHt$HT$L$(fD$ H,Ih(H\$`D$`H\$PHD$XHD$ +D$$H|$E1H|$PH9@HHt$H\$L$(fD$ HM`(Hl$@H\$`HD$8Hl$0D$@H\$PHD$XD$`Mt_D$ +D$$t~H|$E1H|$PH9tH|$0H9mcLIHhE1G@LIHf.Ll$Ht$L|Ht$ LgL|$0LLOLt$PLL7L$ LLLD$HL%I$Ll$HT$ H5L|$ I7Lt$PLLLLHHL%I$HIAU1ATUH`HNdH%(HD$X1HGAfnH%fnA)fbAtJA@AH5D1HT$XdH+%(1H`]A\A]L Ht$0LL$8L$@T$DT$HH2Ho(HtYD$@+D$DH|$01LHt$0LT$8L$@T$DT$HHtHHu1LfHo(HD$(HtދD$@+D$DH|$01H|$(HH/HD$HD$H Ht$0HL$8T$HfD$@HuXHo(H[D$@+D$DtVH|$01HH1kHHu1O@Ld$0Ht$ LHt$$LHt$(LH5HT$L|$HT$(L$$HD$ H}1Ld$0Ht$$LFHt$(L1H5HT$ L|$ HL$(D$$HHHH0DLl$0HT$(H5LIHHT$$H5L|$$HLHHHHAW1AVAUATUHSHfnFdH%(H$HG~H%fn)fbtKt}H51H$dH+%(HĘ[]A\A]A^A_fDH$dH+%(HĘHH=H[]A\A]A^A_fDHHt$0H\$8L$HfD$@HHm(Ht%D$@+D$DH|$018HHt$0H\$8L$HfD$@HHm(L|$0LH|$`4AHcH\$`HD$EL4H|$PAHcLt$PIc1LEHEHT$HBD$@+D$DLLt$P1HT$XI9tMtLHD$HD$H|$`H2HT$hH9$HD$HD$IcHHD$+HHHHHHPyHT$'H5L|$'HD$%DHLHt$(LDLLHt$,LEHD$HSH)HAED1HfDHL$HH9uDAt?HΉHHA9~ DDA9~ DDEHT$IvDAD$H)HQHD1HfAoHL$HH9uDA9D)эqvI4H|$H4ʃ9HcHt$A  PA9~iHcA  PA9~VHcA  PA9~CHcA  PD9}0HcA  PD9}Hc҃A  A9~ HADL$,L$(MHHt$HE~5Ic1DHH9t HL$.ztHEE~0Ic1 HH9tH\$A8tHILt$P1MzHHjf.Lt$,Ll$0LH5L|$,IXLH5L|$,H8LHHHHND1D1HL$HH9uD1AHt$HH9uDLLDHھL11HHfAW1AVAUATUHSHfnFdH%(H$HG~H%fn)fbtSRH5E1H$dH+%(yHĘL[]A\A]A^A_fDH Ht$ HL$(T$8fD$0HLLd$ 1Hm(1LH|$`4AHcLt$`EHRD$0+D$4LH|$`E1HD$hH9a-H Ht$ HL$(T$8fD$0HHm(HD$0+D$4nH|$ E1fH Ht$ HL$(T$8fD$0HHm(Ld$ 1LH|$@4AHcH$H\$@EL4H|$`AHcHD$L|$`EHD$0+D$4/LL|$`E1HD$hI9t MtLH|$@HD$HH9HIcHH$@IcIHD$fIcI@HHHhbHHHH|$ 1E1H|$`4HcH|$`ILE1HHHPODHLDLLHt$LEH$HSH)HAED1HH $HH9uDAt?HΉHHA9~ DDA9~ DDEHD$IWH)HAFD1HA$HL$$HH9uDAtBHΉAHHA9~"ADDA9~ ADDL$LHHE~4Ic1DHH9tH $.ztHE~5Ic1 @HH9t!H\$A.ztH?L|$`E1HL%I$DLLPHt$L;EIVHH)HHAE;D1HAHH9uDAt?AHHD9}"ADDD9} ADDT$LHE~4Ic1HH9tA.ztHH|$`E1HKL%I$:@H5HT$H|$ |$HOHH9L%I$+DE1#D1AHH9uD1fAHL$HH9uwD1DH $HH9uDL1LDLLDH1LZHHHAW1AVAUATUHSHfnFdH%(H$HG~H%fn)fbALIcL>@HHt$@H\$HL$XfD$PH<Hm(L|$@1LH|$p4AHcH\$pHD$Et IcHHD$L4H$AHcH$HD$HL$ Et IcHHD$L4H|$`AHcHL$`Ic1HEHL$HEHT$(H6 D$P+D$TELHD$`E1HD$HHD$hH9t HtHH$HtH$H9tH|$pHtHD$xH9tH$dH+%( HL[]A\A]A^A_HHt$@H\$HL$XfD$PHlHm(HUD$P+D$TH|$@E1nfHHt$@H\$HL$XfD$PHlL|$@1Hm(1LH$4AHcL$EtIcI\HnD$P+D$TLH$E1H$H9HfDH$dH+%(_ HHH=H[]A\A]A^A_fDHHt$@H\$HL$XfD$PHLHm(L|$@1LH$4AHcH$HD$Et IcHHD$L4H|$pAHcLt$pIc1LEHEHT$H D$P+D$T.LLt$pE1HD$xI9t MtLH$HhH$H9RRH5E1>fHHHf.HHHHHHHHHH|$@1E1H$4HcH$ILE1f.DHLHt$8LDLLHt$ D$0+D$4LL|$@E1HD$HI9t MtLH|$`Ht!HD$hH9fH5E1H$dH+%( HĘL[]A\A]A^A_DH Ht$ HL$(T$8fD$0H|Hm(HtD$0+D$4H|$ E1ufDH Ht$ HL$(T$8fD$0HHm(Ld$ 1LH|$@4AHcH$H\$@Et IcHH$L4H|$`AHcHD$L|$`Et IcIHD$HD$0+D$4LL|$`E1HD$hI9t MtLH|$@HpHD$HH9bXfHHHHHHpHHHQH|$ 1E1H|$`4HcH|$`ILE1HHHDHL?Ht$L*DLLHt$LEH$HSH)HAFD1H,H $,HH9uDAt?HΉHHD9} DDD9} DDEHT$IwDAEH)H pD1H@Ao4HL$4HH9uDD9D)эqvI4H|$H4ʃ9HcHt$A  PA9~iHcA  PA9~VHcA  PA9~CHcA  PD9}0HcA  PD9}Hc҃A  D9} HADD$T$LHHE~1Ic1 fHH9tH $.ztHNE~1Ic1 @HH9tH\$A8tHL|$@E1HL%I$DHL4DLLHt$L EH$HSH)HAED1HH $HH9uDAt?HΉHHA9~ DDA9~ DDEHD$IWH)HAFD1HA$HL$$HH9uDAtBHΉAHHA9~"ADDA9~ ADDL$LHHE~4Ic1DHH9tH $.ztHE~5Ic1 @HH9t!H\$A.ztHL|$`E1H:L%I$)H5HT$H|$ |$HHHzL%I$lDDLL Ht$LEIVHH)HAED1HAHH9uDAt?AHHA9~"ADDD9} ADDT$LHE~4Ic1HH9tA.ztHH|$`E1HL%I$@E1E1D1AHH9uTD1fAHL$HH9ugD1DH $HH9uDL1L+(j  % C " 5@nV}  ?q[X   TZ  (5`w:*m-  1ComputeFontSizeForBoundedStringvtkContext2D - Class for drawing 2D primitives to a graphical context. Superclass: vtkObject This defines the interface for drawing onto a 2D context. The context must be set up with a vtkContextDevice2D derived class that provides the functions to facilitate the low level calls to the context. Currently only an OpenGL based device is provided, but this could be extended in the future. vtkRenderingContext2DPython.vtkContext2DV.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. V.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. V.SafeDownCast(vtkObjectBase) -> vtkContext2D C++: static vtkContext2D *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkContext2D C++: vtkContext2D *NewInstance() V.Begin(vtkContextDevice2D) -> bool C++: bool Begin(vtkContextDevice2D *device) Begin painting on a vtkContextDevice2D, no painting can occur before this call has been made. Only one painter is allowed at a time on any given paint device. Returns true if successful, otherwise false. V.GetDevice() -> vtkContextDevice2D C++: virtual vtkContextDevice2D *GetDevice() V.End() -> bool C++: bool End() Ends painting on the device, you would not usually need to call this as it should be called by the destructor. Returns true if the painter is no longer active, otherwise false. V.GetBufferIdMode() -> bool C++: bool GetBufferIdMode() Tell if the context is in BufferId creation mode. Initial value is false. V.BufferIdModeBegin(vtkAbstractContextBufferId) C++: void BufferIdModeBegin(vtkAbstractContextBufferId *bufferId) Start BufferId creation Mode. \pre not_yet: !GetBufferIdMode() \pre bufferId_exists: bufferId!=0 \post started: GetBufferIdMode() V.BufferIdModeEnd() C++: void BufferIdModeEnd() Finalize BufferId creation Mode. It makes sure that the content of the bufferId passed in argument of BufferIdModeBegin() is correctly set. \pre started: GetBufferIdMode() \post done: !GetBufferIdMode() V.DrawLine(float, float, float, float) C++: void DrawLine(float x1, float y1, float x2, float y2) V.DrawLine([float, float, float, float]) C++: void DrawLine(float p[4]) V.DrawLine(vtkPoints2D) C++: void DrawLine(vtkPoints2D *points) Draw a line between the specified points. V.DrawPoly([float, ...], [float, ...], int) C++: void DrawPoly(float *x, float *y, int n) V.DrawPoly(vtkPoints2D) C++: void DrawPoly(vtkPoints2D *points) V.DrawPoly([float, ...], int) C++: void DrawPoly(float *points, int n) V.DrawPoly([float, ...], int, [int, ...], int) C++: void DrawPoly(float *points, int n, unsigned char *colors, int nc_comps) Draw a poly line between the specified points. V.DrawLines(vtkPoints2D) C++: void DrawLines(vtkPoints2D *points) V.DrawLines([float, ...], int) C++: void DrawLines(float *points, int n) Draw multiple lines between the specified pairs of points. \sa DrawPoly() V.DrawPoint(float, float) C++: void DrawPoint(float x, float y) Draw a point at the supplied x and y coordinate V.DrawPoints([float, ...], [float, ...], int) C++: void DrawPoints(float *x, float *y, int n) V.DrawPoints(vtkPoints2D) C++: void DrawPoints(vtkPoints2D *points) V.DrawPoints([float, ...], int) C++: void DrawPoints(float *points, int n) Draw the specified number of points using the x and y arrays supplied V.DrawPointSprites(vtkImageData, vtkPoints2D) C++: void DrawPointSprites(vtkImageData *sprite, vtkPoints2D *points) V.DrawPointSprites(vtkImageData, vtkPoints2D, vtkUnsignedCharArray) C++: void DrawPointSprites(vtkImageData *sprite, vtkPoints2D *points, vtkUnsignedCharArray *colors) V.DrawPointSprites(vtkImageData, [float, ...], int, [int, ...], int) C++: void DrawPointSprites(vtkImageData *sprite, float *points, int n, unsigned char *colors, int nc_comps) V.DrawPointSprites(vtkImageData, [float, ...], int) C++: void DrawPointSprites(vtkImageData *sprite, float *points, int n) 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. V.DrawMarkers(int, bool, [float, ...], int, [int, ...], int) C++: virtual void DrawMarkers(int shape, bool highlight, float *points, int n, unsigned char *colors, int nc_comps) V.DrawMarkers(int, bool, [float, ...], int) C++: virtual void DrawMarkers(int shape, bool highlight, float *points, int n) V.DrawMarkers(int, bool, vtkPoints2D) C++: virtual void DrawMarkers(int shape, bool highlight, vtkPoints2D *points) V.DrawMarkers(int, bool, vtkPoints2D, vtkUnsignedCharArray) C++: virtual void DrawMarkers(int shape, bool highlight, vtkPoints2D *points, vtkUnsignedCharArray *colors) 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 Marker size is determined by the current pen width. \param colors is an optional array of colors. \param nc_comps is the number of components for the color. V.DrawRect(float, float, float, float) C++: void DrawRect(float x, float y, float w, float h) Draw a rectangle with origin at x, y and width w, height h V.DrawQuad(float, float, float, float, float, float, float, float) C++: void DrawQuad(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4) V.DrawQuad([float, ...]) C++: void DrawQuad(float *p) Draw a quadrilateral at the specified points (4 points, 8 floats in x, y). V.DrawQuadStrip(vtkPoints2D) C++: void DrawQuadStrip(vtkPoints2D *points) V.DrawQuadStrip([float, ...], int) C++: void DrawQuadStrip(float *p, int n) Draw a strip of quads V.DrawPolygon([float, ...], [float, ...], int) C++: void DrawPolygon(float *x, float *y, int n) V.DrawPolygon(vtkPoints2D) C++: void DrawPolygon(vtkPoints2D *points) V.DrawPolygon([float, ...], int) C++: void DrawPolygon(float *points, int n) V.DrawPolygon([float, ...], [float, ...], int, [int, ...], int) C++: void DrawPolygon(float *x, float *y, int n, unsigned char *color, int nc_comps) V.DrawPolygon(vtkPoints2D, [int, ...], int) C++: void DrawPolygon(vtkPoints2D *points, unsigned char *color, int nc_comps) V.DrawPolygon([float, ...], int, [int, ...], int) C++: void DrawPolygon(float *points, int n, unsigned char *color, int nc_comps) Draw a polygon specified specified by the points using the x and y arrays supplied V.DrawEllipse(float, float, float, float) C++: void DrawEllipse(float x, float y, float rx, float ry) Draw an ellipse with center at x, y and radii rx, ry. \pre positive_rx: rx>=0 \pre positive_ry: ry>=0 V.DrawWedge(float, float, float, float, float, float) C++: void DrawWedge(float x, float y, float outRadius, float inRadius, float startAngle, float stopAngle) Draw a circular wedge with center at x, y, outer radius outRadius, inner radius inRadius between angles startAngle and stopAngle (expressed in degrees). \pre positive_outRadius: outRadius>=0 \pre positive_inRadius: inRadius>=0 \pre ordered_radii: inRadius<=outRadius V.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) 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 V.DrawArc(float, float, float, float, float) C++: void DrawArc(float x, float y, float r, float startAngle, float stopAngle) Draw a circular arc with center at x,y with radius r between angles startAngle and stopAngle (expressed in degrees). \pre positive_radius: r>=0 V.DrawEllipticArc(float, float, float, float, float, float) C++: void DrawEllipticArc(float x, float y, float rX, float rY, float startAngle, float stopAngle) 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 V.DrawImage(float, float, vtkImageData) C++: void DrawImage(float x, float y, vtkImageData *image) V.DrawImage(float, float, float, vtkImageData) C++: void DrawImage(float x, float y, float scale, vtkImageData *image) V.DrawImage(vtkRectf, vtkImageData) C++: void DrawImage(const vtkRectf &pos, vtkImageData *image) Draw the supplied image at the given x, y location (bottom corner). V.DrawPolyData(float, float, vtkPolyData, vtkUnsignedCharArray, int) C++: void DrawPolyData(float x, float y, vtkPolyData *polyData, vtkUnsignedCharArray *colors, int scalarMode) Draw the supplied polyData at the given x, y position (bottom corner). ote Supports only 2D meshes. V.DrawStringRect(vtkPoints2D, string) C++: void DrawStringRect(vtkPoints2D *rect, const vtkStdString &string) V.DrawStringRect(vtkPoints2D, unicode) C++: void DrawStringRect(vtkPoints2D *rect, const vtkUnicodeString &string) Draw some text to the screen in a bounding rectangle with the alignment of the text properties respecting the rectangle. The points should be supplied as bottom corner (x, y), width, height. V.DrawString(vtkPoints2D, string) C++: void DrawString(vtkPoints2D *point, const vtkStdString &string) V.DrawString(float, float, string) C++: void DrawString(float x, float y, const vtkStdString &string) V.DrawString(vtkPoints2D, unicode) C++: void DrawString(vtkPoints2D *point, const vtkUnicodeString &string) V.DrawString(float, float, unicode) C++: void DrawString(float x, float y, const vtkUnicodeString &string) Draw some text to the screen. V.ComputeStringBounds(string, vtkPoints2D) C++: void ComputeStringBounds(const vtkStdString &string, vtkPoints2D *bounds) V.ComputeStringBounds(string, [float, float, float, float]) C++: void ComputeStringBounds(const vtkStdString &string, float bounds[4]) V.ComputeStringBounds(unicode, vtkPoints2D) C++: void ComputeStringBounds(const vtkUnicodeString &string, vtkPoints2D *bounds) V.ComputeStringBounds(unicode, [float, float, float, float]) C++: void ComputeStringBounds(const vtkUnicodeString &string, float bounds[4]) 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. * NOTE:the text justification from the current text property is * NOT considered when computing these bounds. V.ComputeJustifiedStringBounds(string, [float, float, float, float]) C++: void ComputeJustifiedStringBounds(const char *string, float bounds[4]) Compute the bounds of the supplied string while taking into account the justification and rotation of the currently applied text property. V.ComputeFontSizeForBoundedString(string, float, float) -> int C++: int ComputeFontSizeForBoundedString( const vtkStdString &string, float width, float height) Calculate the largest possible font size where the supplied string will fit within the specified bounds. In addition to being returned, this font size is also used to update the vtkTextProperty used by this object. NOTE: text rotation is ignored for the purposes of this function. V.DrawMathTextString(vtkPoints2D, string) C++: void DrawMathTextString(vtkPoints2D *point, const vtkStdString &string) V.DrawMathTextString(float, float, string) C++: void DrawMathTextString(float x, float y, const vtkStdString &string) V.DrawMathTextString(vtkPoints2D, string, string) C++: void DrawMathTextString(vtkPoints2D *point, const vtkStdString &string, const vtkStdString &fallback) V.DrawMathTextString(float, float, string, string) C++: void DrawMathTextString(float x, float y, const vtkStdString &string, const vtkStdString &fallback) Draw a MathText formatted equation to the screen. See http://matplotlib.sourceforge.net/users/mathtext.html for more information. MathText requires matplotlib and python, and the vtkMatplotlib module must be enabled manually during build configuration. This method will do nothing but print a warning if vtkMathTextUtilities::GetInstance() returns NULL. V.MathTextIsSupported() -> bool C++: bool MathTextIsSupported() Return true if MathText rendering available on the current device. V.ApplyPen(vtkPen) C++: void ApplyPen(vtkPen *pen) Apply the supplied pen which controls the outlines of shapes, as well as lines, points and related primitives. This makes a deep copy of the vtkPen object in the vtkContext2D, it does not hold a pointer to the supplied object. V.GetPen() -> vtkPen C++: vtkPen *GetPen() Get the pen which controls the outlines of shapes, as well as lines, points and related primitives. This object can be modified and the changes will be reflected in subsequent drawing operations. V.ApplyBrush(vtkBrush) C++: void ApplyBrush(vtkBrush *brush) Apply the supplied brush which controls the outlines of shapes, as well as lines, points and related primitives. This makes a deep copy of the vtkBrush object in the vtkContext2D, it does not hold a pointer to the supplied object. V.GetBrush() -> vtkBrush C++: vtkBrush *GetBrush() Get the pen which controls the outlines of shapes as well as lines, points and related primitives. V.ApplyTextProp(vtkTextProperty) C++: void ApplyTextProp(vtkTextProperty *prop) Apply the supplied text property which controls how text is rendered. This makes a deep copy of the vtkTextProperty object in the vtkContext2D, it does not hold a pointer to the supplied object. V.GetTextProp() -> vtkTextProperty C++: vtkTextProperty *GetTextProp() Get the text properties object for the vtkContext2D. V.SetTransform(vtkTransform2D) C++: void SetTransform(vtkTransform2D *transform) Set the transform for the context, the underlying device will use the matrix of the transform. Note, this is set immediately, later changes to the matrix will have no effect until it is set again. V.GetTransform() -> vtkTransform2D C++: vtkTransform2D *GetTransform() Compute the current transform applied to the context. V.AppendTransform(vtkTransform2D) C++: void AppendTransform(vtkTransform2D *transform) Append the transform for the context, the underlying device will use the matrix of the transform. Note, this is set immediately, later changes to the matrix will have no effect until it is set again. The matrix of the transform will multiply the current context transform. V.PushMatrix() C++: void PushMatrix() Push/pop the transformation matrix for the painter (sets the underlying matrix for the device when available). V.PopMatrix() C++: void PopMatrix() Push/pop the transformation matrix for the painter (sets the underlying matrix for the device when available). V.ApplyId(int) C++: void ApplyId(vtkIdType id) Apply id as a color. V.FloatToInt(float) -> int C++: static int FloatToInt(float x) Float to int conversion, performs truncation but with a rounding tolerance for float values that are within 1/256 of their closest integer. V.GetContext3D() -> vtkContext3D C++: virtual vtkContext3D *GetContext3D() Get the vtkContext3D device, in order to do some 3D rendering. This API is very experimental, and may be moved around. V.SetContext3D(vtkContext3D) C++: virtual void SetContext3D(vtkContext3D *context) Get the vtkContext3D device, in order to do some 3D rendering. This API is very experimental, and may be moved around. @iqVV *vtkPoints2D *vtkUnsignedCharArray@VVV *vtkImageData *vtkPoints2D *vtkUnsignedCharArrayUH-HH=HHH]HHD;GCC: (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0GNUzRx  0 D X lEDPa AE H`a G O|RO|RO|R<EY B W(EAD`j AAJ @H@ I \H@ I xH@ I ED@ AG ED@ AG ED@ AG ED@ AG $ED@ AG HED@ AG lED@ AG ED@ AG ED@ AG EDP AK EDP AK EDP AK DEDP AK hEDP AK EDP AK EDP AK EDP AK EDP AK (FAD` ABG @H[FBB B(A0Dp 0A(B BBBC zPLRx <$hFBB A(D (D BBBF d<hFBB A(D (D BBBF 4aFBA D  DBBJ D<iFBB A(A0D 0D(A BBBF DiFBB A(A0D 0D(A BBBF <aFBA A(D (D ABBE T@sFBB A(A0Dp 0A(A BBBD (@9FAD` ABC (l9FAD` ABC 4uFBA D  DBBJ H0^FAA D`  AABH <vFBA A(D (D ABBB <vFBA A(D (D ABBB <<\rFBA A(D (D ABBE @D FBB A(A0D 0A(A BBBH ( WFADp ABC 8 FBB A(D (A BBBG gFD@ EE LFBB B(A0A8G 8D0A(B BBBG &( rFADp ABC L,FBB B(A0A8D 8D0A(B BBBC |(( rFADp ABC LFBB B(A0A8D 8D0A(B BBBA ( FADp ABC LlyFBB B(A0A8D 8D0A(B BBBE !LFBB B(A0A8D 8D0A(B BBBE 0!PTFBB B(A0D8GV 8D0A(B BBBE :4T FFD` ABG X NBH D FGB A(A0Dg 0A(A BBBD L !Dp FGB A(A0Dg 0A(A BBBD !D FDB A(A0D 0A(A BBBA $ !dH yFGB B(A0A8Gt 8D0A(B BBBE [ 8N0A(B BBBN =0\FDA D|  ABBH d FDB B(A0D8Gu 8A0A(B BBBG ^ 8N0A(B BBBK p :L /FDB B(A0D8Gz 8D0A(B BBBG [h sFDB B(A0D8G 8D0A(B BBBI > 8N0A(B BBBK t P FDB B(A0D8GC 8D0A(B BBBF MFF0OFDD n ABA DDB:Em EDP AK 0(FBA Dp  ABBF D 8FBB A(A0D 0D(A BBBD !D@EE P{ K r N .v.0.c. 6       MxO0O`.O]``60c` 0 7 g  p p`H`v````#`I`sp[h@h>qa8 iTMi{k a!p!sM"9v0$9p%u &^' P(vU  )v  P+r9 ~ , p.W / `1g< 2r & 4r  6  P 7rz p9 < `; =yM S! @ t! C:Q@Hz `J!M&!YQ!pVy``2=JYt] `o:d/3[cls``0| ?X`t: p84'!hP`H6 (   3GRa%+j1t7=CIOU[agmsy $,<KYiv 1NVc!o'{-39?EKQW]ciou{ " " " (TcB"<\c ;`,R9k/!!:I&g (Jj-s1 C Y m   !@!z!!!!!"@"b"""""*#J#z####$b$n$$$%:%t%%%%*&P&~&&&&'8'W'ЈMo'~''' O'''' ((I(h(((),)8)K)\)o)))))))_ZL24PyvtkContext2D_StaticNewv_ZL27PyvtkContext2D_SafeDownCastP7_objectS0__ZL25PyvtkContext2D_FloatToIntP7_objectS0__ZL34PyvtkContext2D_ComputeStringBoundsP7_objectS0__ZL42PyvtkContext2D_ComputeStringBounds_Methods_ZL25PyvtkContext2D_DrawStringP7_objectS0__ZL33PyvtkContext2D_DrawString_Methods_ZL29PyvtkContext2D_DrawStringRectP7_objectS0__ZL37PyvtkContext2D_DrawStringRect_Methods_ZL23PyvtkContext2D_IsTypeOfP7_objectS0__ZL24PyvtkContext2D_PopMatrixP7_objectS0__ZL25PyvtkContext2D_PushMatrixP7_objectS0__ZL30PyvtkContext2D_BufferIdModeEndP7_objectS0__ZL27PyvtkContext2D_GetTransformP7_objectS0__ZL34PyvtkContext2D_MathTextIsSupportedP7_objectS0__ZL21PyvtkContext2D_GetPenP7_objectS0__ZL23PyvtkContext2D_GetBrushP7_objectS0__ZL26PyvtkContext2D_GetTextPropP7_objectS0__ZL18PyvtkContext2D_EndP7_objectS0__ZL30PyvtkContext2D_GetBufferIdModeP7_objectS0__ZL27PyvtkContext2D_GetContext3DP7_objectS0__ZL24PyvtkContext2D_GetDeviceP7_objectS0__ZL32PyvtkContext2D_BufferIdModeBeginP7_objectS0__ZL22PyvtkContext2D_ApplyIdP7_objectS0__ZL30PyvtkContext2D_AppendTransformP7_objectS0__ZL28PyvtkContext2D_ApplyTextPropP7_objectS0__ZL27PyvtkContext2D_SetTransformP7_objectS0__ZL23PyvtkContext2D_ApplyPenP7_objectS0__ZL25PyvtkContext2D_ApplyBrushP7_objectS0__ZL26PyvtkContext2D_DrawLine_s3P7_objectS0__ZL20PyvtkContext2D_BeginP7_objectS0__ZL24PyvtkContext2D_DrawPointP7_objectS0__ZL34PyvtkContext2D_DrawPointSprites_s2P7_objectS0__ZL32PyvtkContext2D_DrawStringRect_s2P7_objectS0__ZL32PyvtkContext2D_DrawStringRect_s2P7_objectS0_.cold_ZL28PyvtkContext2D_DrawString_s3P7_objectS0__ZL28PyvtkContext2D_DrawString_s3P7_objectS0_.cold_ZL37PyvtkContext2D_ComputeStringBounds_s3P7_objectS0__ZL37PyvtkContext2D_ComputeStringBounds_s3P7_objectS0_.cold_ZL32PyvtkContext2D_DrawStringRect_s1P7_objectS0__ZL32PyvtkContext2D_DrawStringRect_s1P7_objectS0_.cold_ZL28PyvtkContext2D_DrawString_s1P7_objectS0__ZL28PyvtkContext2D_DrawString_s1P7_objectS0_.cold_ZL37PyvtkContext2D_ComputeStringBounds_s1P7_objectS0__ZL37PyvtkContext2D_ComputeStringBounds_s1P7_objectS0_.cold_ZL26PyvtkContext2D_DrawLine_s2P7_objectS0__ZL23PyvtkContext2D_DrawRectP7_objectS0__ZL26PyvtkContext2D_DrawEllipseP7_objectS0__ZL28PyvtkContext2D_DrawString_s4P7_objectS0__ZL28PyvtkContext2D_DrawString_s4P7_objectS0_.cold_ZL18PyvtkContext2D_IsAP7_objectS0__ZL28PyvtkContext2D_DrawString_s2P7_objectS0__ZL28PyvtkContext2D_DrawString_s2P7_objectS0_.cold_ZL36PyvtkContext2D_DrawMathTextString_s2P7_objectS0__ZL36PyvtkContext2D_DrawMathTextString_s2P7_objectS0_.cold_ZL46PyvtkContext2D_ComputeFontSizeForBoundedStringP7_objectS0__ZL46PyvtkContext2D_ComputeFontSizeForBoundedStringP7_objectS0_.cold_ZL43PyvtkContext2D_ComputeJustifiedStringBoundsP7_objectS0__ZL22PyvtkContext2D_DrawArcP7_objectS0__ZL27PyvtkContext2D_DrawPolyDataP7_objectS0__ZL26PyvtkContext2D_NewInstanceP7_objectS0__ZL36PyvtkContext2D_DrawMathTextString_s3P7_objectS0__ZL36PyvtkContext2D_DrawMathTextString_s3P7_objectS0_.cold_ZL30PyvtkContext2D_DrawEllipticArcP7_objectS0__ZL37PyvtkContext2D_ComputeStringBounds_s4P7_objectS0__ZL37PyvtkContext2D_ComputeStringBounds_s4P7_objectS0_.cold_ZL24PyvtkContext2D_DrawWedgeP7_objectS0__ZL37PyvtkContext2D_ComputeStringBounds_s2P7_objectS0__ZL37PyvtkContext2D_ComputeStringBounds_s2P7_objectS0_.cold_ZL31PyvtkContext2D_DrawEllipseWedgeP7_objectS0__ZL29PyvtkContext2D_DrawPolygon_s5P7_objectS0__ZL29PyvtkContext2D_DrawPolygon_s5P7_objectS0_.cold_ZL34PyvtkContext2D_DrawPointSprites_s4P7_objectS0__ZL34PyvtkContext2D_DrawPointSprites_s4P7_objectS0_.cold_ZL29PyvtkContext2D_DrawPolygon_s1P7_objectS0__ZL29PyvtkContext2D_DrawPolygon_s1P7_objectS0_.cold_ZL23PyvtkContext2D_DrawLineP7_objectS0__ZL31PyvtkContext2D_DrawLine_Methods_ZL24PyvtkContext2D_DrawLinesP7_objectS0__ZL24PyvtkContext2D_DrawLinesP7_objectS0_.cold_ZL28PyvtkContext2D_DrawQuadStripP7_objectS0__ZL28PyvtkContext2D_DrawQuadStripP7_objectS0_.cold_ZL23PyvtkContext2D_DrawQuadP7_objectS0__ZL23PyvtkContext2D_DrawQuadP7_objectS0_.cold_ZL33PyvtkContext2D_DrawMathTextStringP7_objectS0__ZL41PyvtkContext2D_DrawMathTextString_Methods_ZL33PyvtkContext2D_DrawMathTextStringP7_objectS0_.cold_ZL24PyvtkContext2D_DrawImageP7_objectS0__ZL31PyvtkContext2D_DrawPointSpritesP7_objectS0__ZL39PyvtkContext2D_DrawPointSprites_Methods_ZL31PyvtkContext2D_DrawPointSpritesP7_objectS0_.cold_ZL25PyvtkContext2D_DrawPointsP7_objectS0__ZL25PyvtkContext2D_DrawPointsP7_objectS0_.cold_ZL26PyvtkContext2D_DrawPolygonP7_objectS0__ZL34PyvtkContext2D_DrawPolygon_Methods_ZL26PyvtkContext2D_DrawPolygonP7_objectS0_.cold_ZL23PyvtkContext2D_DrawPolyP7_objectS0__ZL23PyvtkContext2D_DrawPolyP7_objectS0_.cold_ZL19PyvtkContext2D_Type_ZL22PyvtkContext2D_Methods_GLOBAL__sub_I_vtkContext2DPython.cxx_ZStL8__ioinit_ZL27PyvtkContext2D_SetContext3DP7_objectS0__ZL29PyvtkContext2D_DrawMarkers_s4P7_objectS0__ZL29PyvtkContext2D_DrawMarkers_s2P7_objectS0__ZL29PyvtkContext2D_DrawMarkers_s2P7_objectS0_.cold_ZL26PyvtkContext2D_DrawMarkersP7_objectS0__ZL34PyvtkContext2D_DrawMarkers_Methods_ZL26PyvtkContext2D_DrawMarkersP7_objectS0_.cold.LC0.LC1.LC2.LC5.LC6.LC3.LC4.LC7.LC8.LC9.LC11.LC10.LC12.LC13.LC14.LC15.LC16.LC17.LC18.LC19.LC20.LC21.LC22.LC23.LC24.LC25.LC26.LC27.LC28.LC29.LC30.LC31.LC32.LC33.LC34.LC35.LC36.LC37.LC38.LC39.LC40.LC41.LC42.LC43.LC50.LC51.LC53.LC55.LC57.LC59.LC60.LC61.LC62.LC63.LC65.LC67.LC69.LC70.LC74.LC76.LC78.LC81.LC82.LC84.LC87.LC90.LC91.LC92.LC89_ZN12vtkContext2D9GetDeviceEv_ZN12vtkContext2D12GetContext3DEv_ZN12vtkContext2D3NewEv_ZNK12vtkContext2D19NewInstanceInternalEv_ZN13vtkPythonArgs13ArgCountErrorEii_ZN13vtkPythonArgs17GetArgAsVTKObjectEPKcRbPyErr_Occurred_ZN13vtkPythonUtil20GetObjectFromPointerEP13vtkObjectBase__stack_chk_fail_ZN13vtkPythonArgs8GetValueERfPyLong_FromLong_ZN17vtkPythonOverload10CallMethodEP11PyMethodDefP7_objectS3__ZN13vtkPythonArgs13ArgCountErrorEiPKc_ZN12vtkContext2D3IsAEPKcstrcmp_ZN13vtkObjectBase8IsTypeOfEPKc_ZN13vtkPythonArgs8GetValueERPc_ZN13vtkPythonArgs19GetSelfFromFirstArgEP7_objectS1__ZN12vtkContext2D9PopMatrixEv_GLOBAL_OFFSET_TABLE__Py_NoneStruct_ZN12vtkContext2D10PushMatrixEv_ZN12vtkContext2D15BufferIdModeEndEv_ZN12vtkContext2D12GetTransformEv_ZN12vtkContext2D19MathTextIsSupportedEvPyBool_FromLong_ZN12vtkContext2D6GetPenEv_ZN12vtkContext2D8GetBrushEv_ZN12vtkContext2D11GetTextPropEv_ZN12vtkContext2D3EndEv_ZNK12vtkContext2D15GetBufferIdModeEv_ZN12vtkContext2D17BufferIdModeBeginEP26vtkAbstractContextBufferId_ZN13vtkPythonArgs8GetValueERx_ZN12vtkContext2D7ApplyIdEx_ZN12vtkContext2D15AppendTransformEP14vtkTransform2D_ZN12vtkContext2D13ApplyTextPropEP15vtkTextProperty_ZN12vtkContext2D12SetTransformEP14vtkTransform2D_ZN12vtkContext2D8ApplyPenEP6vtkPen_ZN12vtkContext2D10ApplyBrushEP8vtkBrush_ZN12vtkContext2D8DrawLineEP11vtkPoints2D_ZN12vtkContext2D5BeginEP18vtkContextDevice2D_ZN12vtkContext2D9DrawPointEff_ZN12vtkContext2D16DrawPointSpritesEP12vtkImageDataP11vtkPoints2DP20vtkUnsignedCharArrayDW.ref.__gxx_personality_v0_ZN16vtkUnicodeStringC1Ev_ZdlPv_ZN13vtkPythonArgs8GetValueER16vtkUnicodeString_ZN12vtkContext2D14DrawStringRectEP11vtkPoints2DRK16vtkUnicodeString_Unwind_Resume_ZN12vtkContext2D10DrawStringEP11vtkPoints2DRK16vtkUnicodeString_ZN12vtkContext2D19ComputeStringBoundsERK16vtkUnicodeStringP11vtkPoints2D_ZN13vtkPythonArgs8GetValueERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_ZN12vtkContext2D14DrawStringRectEP11vtkPoints2DRK12vtkStdString_ZN12vtkContext2D10DrawStringEP11vtkPoints2DRK12vtkStdString_ZN12vtkContext2D19ComputeStringBoundsERK12vtkStdStringP11vtkPoints2D_ZN13vtkPythonArgs8GetArrayEPfi_ZN12vtkContext2D8DrawLineEPf_ZN13vtkPythonArgs8SetArrayEiPKfi_ZN12vtkContext2D8DrawRectEffff_ZN12vtkContext2D11DrawEllipseEffff_ZN12vtkContext2D10DrawStringEffRK16vtkUnicodeString_ZN12vtkContext2D10DrawStringEffRK12vtkStdString_ZN12vtkContext2D18DrawMathTextStringEffRK12vtkStdString_ZN12vtkContext2D31ComputeFontSizeForBoundedStringERK12vtkStdStringff_ZN12vtkContext2D28ComputeJustifiedStringBoundsEPKcPf_ZN12vtkContext2D7DrawArcEfffff_ZN13vtkPythonArgs8GetValueERi_ZN12vtkContext2D12DrawPolyDataEffP11vtkPolyDataP20vtkUnsignedCharArrayiPyVTKObject_CheckPyVTKObject_GetObjectPyVTKObject_SetFlag_ZN12vtkContext2D18DrawMathTextStringEP11vtkPoints2DRK12vtkStdStringS4__ZN12vtkContext2D15DrawEllipticArcEffffff_ZN12vtkContext2D19ComputeStringBoundsERK16vtkUnicodeStringPf_ZN12vtkContext2D9DrawWedgeEffffff_ZN12vtkContext2D19ComputeStringBoundsERK12vtkStdStringPf_ZN12vtkContext2D16DrawEllipseWedgeEffffffff_ZN13vtkPythonArgs10GetArgSizeEi_ZN13vtkPythonArgs5ArrayIhEC1El_ZdaPv_ZN13vtkPythonArgs8GetArrayEPhi_ZN12vtkContext2D11DrawPolygonEP11vtkPoints2DPhi_ZN13vtkPythonArgs8SetArrayEiPKhi_ZN13vtkPythonArgs5ArrayIfEC1El_ZN12vtkContext2D16DrawPointSpritesEP12vtkImageDataPfi_ZN12vtkContext2D11DrawPolygonEPfS0_i_ZN12vtkContext2D8DrawLineEffff_ZN12vtkContext2D9DrawLinesEP11vtkPoints2D_ZN12vtkContext2D9DrawLinesEPfi_ZN12vtkContext2D13DrawQuadStripEP11vtkPoints2D_ZN12vtkContext2D13DrawQuadStripEPfi_ZN12vtkContext2D8DrawQuadEffffffff_ZN12vtkContext2D8DrawQuadEPf_ZN12vtkContext2D18DrawMathTextStringEffRK12vtkStdStringS2__ZN12vtkContext2D18DrawMathTextStringEP11vtkPoints2DRK12vtkStdString_Py_Dealloc_ZN12vtkContext2D9DrawImageEfffP12vtkImageData_ZN12vtkContext2D9DrawImageEffP12vtkImageData_ZN13vtkPythonArgs21GetArgAsSpecialObjectEPKcPP7_object_ZN12vtkContext2D9DrawImageERK8vtkRectfP12vtkImageData_ZN12vtkContext2D16DrawPointSpritesEP12vtkImageDataPfiPhi_ZN12vtkContext2D16DrawPointSpritesEP12vtkImageDataP11vtkPoints2D_ZN12vtkContext2D10DrawPointsEPfS0_i_ZN12vtkContext2D10DrawPointsEPfi_ZN12vtkContext2D10DrawPointsEP11vtkPoints2D_ZN12vtkContext2D11DrawPolygonEPfiPhi_ZN12vtkContext2D11DrawPolygonEP11vtkPoints2D_ZN12vtkContext2D11DrawPolygonEPfi_ZN12vtkContext2D11DrawPolygonEPfS0_iPhi_ZN12vtkContext2D8DrawPolyEPfiPhi_ZN12vtkContext2D8DrawPolyEPfS0_i_ZN12vtkContext2D8DrawPolyEP11vtkPoints2D_ZN12vtkContext2D8DrawPolyEPfiPyvtkContext2D_ClassNewPyVTKClass_AddPyvtkObject_ClassNewPyType_ReadyPyVTKAddFile_vtkContext2DPyDict_SetItemString_ZNSt8ios_base4InitC1Ev_ZNSt8ios_base4InitD1Ev__dso_handle__cxa_atexit_ZN12vtkContext2D12SetContext3DEP12vtkContext3D_ZN13vtkPythonArgs8GetValueERb_ZN12vtkContext2D11DrawMarkersEibP11vtkPoints2DP20vtkUnsignedCharArray_ZN12vtkContext2D11DrawMarkersEibPfi_ZN12vtkContext2D11DrawMarkersEibP11vtkPoints2D_ZN12vtkContext2D11DrawMarkersEibPfiPhiPyType_TypePyVTKObject_DeletePyVTKObject_ReprPyVTKObject_StringPyObject_GenericGetAttrPyObject_GenericSetAttrPyVTKObject_AsBufferPyVTKObject_TraversePyVTKObject_GetSetPyVTKObject_NewPyObject_GC_Del,}`~ ?k||$X|\ot|*]mu-Qafr*}!16B*M*Q!n.Qaiv}! 1 9 F M        Q        ^        A Y f } *   ! 9 F ] *k   #2DIU*`+<AM*X"49E*P"49E*P"49E*P"49E*P"49E*P"49E*P"4;IP/GLX*c08LThp*7]t *(g*=E^ty*;R*H%?UZj*y);i*&      !!-!2!B!*Q!!!"D"]"""*"""#l######$$$*%$S$$$$$%%B%G%W%*e%%%%&A&Z&n&&&&&&*&'v''''*''''((4(J(v(((!)N)_)s))))*))g*y*****++'+*6+v+++),L,],n,,,,,,Z-----(.8.*I.c.j..././?/P/a/r////*//T0000000011.1*A1W11112*%282G2T2h2x22 2233333 4434P4k4 p44*445A5^5o555555 56*6J66666 7737S7 77*7778l88888889;9 @9P9*^99:&:Q:|:::;;*!;;;B;;;<<-<><O<`<u<<<<<<*=:=====!>?>Q>x>>>>?@@)@A@*y@@AANAjAAAABB,BABB!C9CACYC*CC)DI|| TI|IIIIIII*JiJnJJJJ%K8KnKKKKKKK*L'LL MM1M*DM\MnMMMMINNN{NNNOONOvOOOOOO*OPPPPQ*$Qz*z]{g{{{{{|||&}\}}}}}!~@~c~h~~~3Fp$Ddڀ0Q_w*1C}*ʅ2*'؆3.*Ї2G_rو{|5{6{7/4>I9#2Vb*t>{>O?_j{ϋ*@ 8ь)L^?ɍÎێ*A18|3&8ё0[r?̒KYr*?Ǖ *(B>C– `4** *4*P*g]!*~&*)*B+*,*4*7*N;*8@*OC*p!H*-H*IIM*Q*_V* CWY*.Y*E^gd*ksd*l*l*l*&p{*{*8{*|*Y|*r|*r****È*k"D*##Ӗ*Dߖ*[&+8,4HP_gv~08GOhp &.=ETck8QYr#<D[rzJqn8o o@p4m:*;!<&=-5{qDB0EXFGHIJKL8M@NaB (&8B@HXB`oh`1xBP`B B0 B Bp Bp (`8Bh@H@HXBh `h0|xB JB `B dBh ]BPB ("8B@HQXB@`hMxBplB 0$B7B`;BNp.B {(48B @HYXB("`Vh/xB#RB$G0B&3BX(1,B+BP+B- (pV8B.@HXB`2`vh`xB2B4`B4B 6K`B6` B7 i(`8BP8@H0XBh9`,h`xB9tBX;jB;$pB<(B< B= (p8Bh>h)x 2% 7p9HO( 68`hxgP( @xp% g(8xhCx=B8?( p8 Bh?H @X  p!  `  4H\p0D`|`0(` L0 p   p p$`H`l````` `Lp,*,@,!P*Y,:py,B*8,[ ,c*T,x4=,|*k, ,*,p!D"p0$p%,*,&(P(1,h*q,),*, P+,( *1 ,*H , p. / `1 2! ,2h *q ,G 4  6 ,O *  ,i, 7X p9a ,q *< , `; = ,H *SQ ,l @u , *t , C ,4 *= ,X @H J , * ,! M,)D*M,OhQq,W*,xpV,<*2E,`Y],*o, d),p*y,%l,-* ,$0|-,x*,Ј qp,`i,*',*P,2*H,`.symtab.strtab.shstrtab.rela.text.data.bss.text._ZN12vtkContext2D9GetDeviceEv.text._ZN12vtkContext2D12GetContext3DEv.rela.text._ZNK12vtkContext2D19NewInstanceInternalEv.rodata.str1.1.rodata._ZN12vtkContext2D3IsAEPKc.str1.1.rela.text._ZN12vtkContext2D3IsAEPKc.rela.text.unlikely.gcc_except_table.rodata.str1.8.rela.rodata.rela.text.startup.rela.init_array.rela.data.rel.rela.data.rel.local.rodata.cst4.rela.data.rel.local.DW.ref.__gxx_personality_v0.comment.note.GNU-stack.note.gnu.property.rela.eh_frame.group@(H(P (\ (h ( @@Mpe(&c,c1p U  }@( 22| <@Ȳx(̛~@@(#Jh52?IXD@(Vp:Q@x(id@ (z u@8 (` @X(@ P@((!0X, 0@@(&h) @#)