x(__text__TEXT(__gcc_except_tab__TEXT__literal8__TEXT@h__data__DATAP x__cstring__TEXTМB__compact_unwind__LD  }__eh_frame__TEXT # h2  )# #2$ PkkmUHH=H5HH uHH=H]ÐUH]fDUHSPHH=H5HRH uHH=H5HHt H tH[]H=H[]fUHAVSH0HuHHEЋFEHEHEH}ȃu\Hut^H]H=HAtH=UHt HLcHuL1H0[A^]ÐUHAWAVSH(HuHHED~D}HG]ԉ]؅yHHLw(HEMA)AuQHuH}t|}L}tYH=LAtOH=hLtULLE~A1f.AA.Du z HH9uHuH}1LDHHHH}HEH9HH}HEH9t HtH fUHAWAVSH(HuHLHED~D}HG]ԉ]؅y HHtoLw(MtfA)AuJHuH}tLHuH}t;EMLHuHHH}1H([A^A_]f.UHAWAVAUATSH^HG)ЃUHuHHE]ȉỦUЅyHHHG(HELeE1L1ÍHcHxLxH]HcILELÍHcHPLPE1H]HcIIDH}@E+ẼH}LHUH}LHUH}HuHEDž-}rII9PII9C1HHHHHtA4A4HHuHA A ALALALALAL AL ALALALALALALALALHH9uHuHHE]ȉỦUЅyHHH_(HH5`H}HxxHHHL-IEHuHtHE]ȉỦUЅyHHL(H}E11AC6HcHxLxEIcIIDMWE+ẼH}LDH}HPEE ArKH98JI9+1HHLLHtf.@A44HHuHA ALLALLAL L ALLALLALLALLHI9u]H5 E1eH}E13H}E1HPHXH9t HtHxHEH9t HtLHĈ[A\A]A^A_]1E1)DHpHHH‰уHs1hHH)1AALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpH HuHt(HHADA D H HuL9PLLE~51A.u z HI9uHuH}1LDHpL-IEHpHHH‰уHs1pHH)1AALAALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpH HuHt*HHADA ADA H HuH9HpHEAŅb}rKH9JI91HHLLHtA44HHuHA ALLALLAL L ALLALLALLALLHI9uDHpHHH‰уHs1hHH)1AALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpH HuHt(HHADA D H HuL9MH}LLHp}~71AA.u z HH9uHuH}1LHM}~91A.u z HI9uHuH}LHMHL-IEHPHXH9HHPHXH9tHtHHxHEH9t HtH @UHAWAVAUATSHHHZHG)σmHUH=څH}]MMyHHHHZH^(HMH5QH}H``)IH5ҷH}H``HLHHL-IE%HUH=#H}]MMyHHHHHF(HEL}LAC6HcH`H`E1EIcHLELAH]C?HcH}HEIcHE1EIDH}4IŋE+E H5 H}HUHP}H}HuDH}HuH}LDH}HuEEArHMJI93KH9&1HHLLHH}ȋ4A4HHuH=HĈ[A\A]A^A_]H5]E1JH}E1H}HEH9t HtH`HhH9t HtLHĈ[A\A]A^A_]1H}H A LALLALL AL LALLALLALLALHI9uDHpHHH‰уHs1H}lHH)1H}LAALD L0AD AL0D@LPAD@ALPD`LpAD`ALpH HuHt(HHD ADA H HuL9LXDHEEMOA s 1HUHUIDH9sLHI9s1ЃHpHHH‰уH`s1MkHH)1MAALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpHHuHt$HHADA D H HuHUH9t[HHHMHtA HHuHHUr/A ALLALLALLHH9uыMDMH}HPHUHXE~=1HMA.u z HH9uHuH}HUDE~61AL: u HH9EuHuH}LDHlL-IEH}HEH9`eHHH}HEH9t HtH`HhH9t HtH UHAWAVAUATSHHHZHG)σ3GHUH=H}]MMyHHHHHF(HEEL}LAC6HcHXHXE1EIcHLELAH]C?HcH}HEIcHE1EIDH}IŋE+EH}HuH}HunH}HuDVH}Hx>H}LD'H}H|DHEEA|1HU^HUH=H}]MMyHHHH H^(EHHXH}tzH}HutiH5_H}HU}tO}XMHHH=HĈ[A\A]A^A_]H5E1JH}E1H}HEH9t HtHXH`H9t HtLHĈ[A\A]A^A_]1yELHHAHnL-IEHMHUHI9sIH9s1Ѓ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Ճ}uЊEDx|t $H}HMMH}HL $HMMAE~>1HMA.u z HH9EuHuH}HUDE~61AL: u HH9EuHuH}LDHL-IEH}HEH9HH}HEH9tHt HHXH`H9t HtH UHAWAVSH8HuH~HED~D}HG]̉]ЅyHHLw(MA)H}AurHuttH}HutcH}HutRH}HutAEMU]LHuHH1H8[A^A_]E1MYf.fUHAWAVAUATSHh^HG)Ѓ?HuHa~HE]ȉỦUЅyHHH_(H`H}HxHH}Hu3H}HuH}Hu H}HuH}HuH}HuH}HuxMU]emu}HHtL%I$HuH+}HE]ȉỦUЅyHHdL(H}E11AC6HcHxLxEIcI\IDM>E+ẼH}LDEEArKDH9JI91HHLLHtfDAt4HHuHafDAL ALLALLAL L ALLALLALLALLHI9uH5{E1`H}+1HuE1DHpHHH‰уHs1iHH)1ADALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpH HuHt)HHADALD H HuL9mLLE~91AD.u z HI9uHuH}1LDHt/E1HxHEH9t HtLHh[A\A]A^A_]L%I$HxHEH9uHHxHEH9t HtH f.DUHAWAVAUATSHH^HG)ЃHuHzHE]ȉỦUЅyHHH_(HH51H}HU}HHHHHHuHwzHE]ȉỦUЅyHHL(H}11AC6HcH}LeEIcM,LDM/E+Ẽ H}LDH}HuDEArII9IDI91HHHHHt f.DA4AtHHuHDA ALALALALALAL AL ALALALALALALALALHH9u$H5y1,H}1H}HEH9t HtHHH[A\A]A^A_]E1e؃HpHHH‰уHs1qHH)1AALADALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpH HuHt+HHADA ADALH HuH9>ULLE~A1f.AA.Du z HH9uHuH}1LDHHHH}HEH9HH}HEH9t HtH fUHAWAVAUATSHHI^HG)GH=HcHHUHwHE]uĉuȅyLHIHtZIX(HtQH5 H}H``t1HHHuL-IE~H5'wE1jHUHwHE]uĉuȅyLHIHLMx(H}E11AC6HcH`L`EIcIIDME+Eă+H}LD'H}H(EEArKH9JI91HHLLHtA44HHuHFA ALLALLAL L ALLALLALLALLHI9uH=LH[A\A]A^A_]HUHuHE]uĉuȅyLHIHI@(HELeE1L1ÍHcH`L`H]HcILELÍHcH(H(LcHMIE1H]MDH}E+EăH}LH]H}HPqH}HuHUXH}HuC߅rII9II91HHHHHtA4A4HHuHA A ALALALALAL AL ALALALALALALALALHH9ueHUHsHE]uĉuȅyLHIHI@(HEH]E1H1AC?HcH`L`EIcILEH߾LeHcH(H(E1HcHMHLEH}AH]CD-HcHPHPLHcHMHE1HEIDH}E+EăzH}HuDuH}HuHU\H}HuGH}HuHU.H}HLEELELMH}rArJI9KH91HHLLHt4A4HHuH% A LALLALL AL LALLALLALLALHI9uH}E1H`HhH9H}E13H}E1HPHXH9t HtH(H0H9t HtH`HhH9t HtLH[A\A]A^A_]E11-1 DHpHHH‰уHs1hHH)1AALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpH HuHt(HHADA D H HuL9(LLE~51A.u z HI9uHuH}1LDHL-IEH`HhH9HpHHH‰уHs11DЃHpHHH‰уH1)HH)1AALAALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpH HuHt*HHADA ADA H HuH9H}HEAŅHMQ} rHMJ)I9syK,H9sp1HHLLHtHMAHHuHMHH]ATATTATTATHI9uDHpHHH‰׃H`s1HMlHH)1HMLAALD L0AD AL0D@LPAD@ALPD`LpAD`ALpHHuHt$HHD ADA H HuL9PDEH}LHM~51AA.u z HH9uHuH}1L}~:1HM A: u HI9u HuH}HUHMH"L-IEJHH)1LAALD L0AD AL0D@LPAD@ALPD`LpAD`ALpH HuHt(HHD ADA H HuL9DEtArII9II91HHHHHtA4A4HHuH&A A ALALALALAL AL ALALALALALALALALHH9uHpHHH‰уHs1pHH)1AALAALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpH HuHt*HHADA ADA H HuH9HL HEAŅLEM} rHMJ)H9suJ+H9sl1HHLLHtLEA HHuLEHA ALLALLALLHI9uDHpHHH‰уH`s1LElHH)1LEAALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpHHuHt$HHADA D H HuL9MDLH}HuHUH E~:1HMA.u z HH9uHuH}1HUD}~B1HMA.uzHH9u HuH}HUHM}~91HM : u HI9u HuH}HUHMHL-IEHPHXH9HHPHXH9t+Ht&HH(H0H9u/*HH(H0H9tHt HH`HhH9t HtH PEeIUHAWAVSH8HuHiHED~D}HG]̉]ЅyHHLw(MA)H}AurHuttH}HutcH}HutRH}HutAEMU]LHuHH1H8[A^A_]E1MYf.fUHAWAVSH8HuHiHED~D}HG]ĉ]ȅyHHLw(MA)H}AHuH}HuH}Hut~H}HutmH}Hut\H}HutKEMU]emLHuHH1H8[A^A_]E1M!@UHAWAVSHHHuHjHED~D}HG]]yHHLw(MA)H}AHuH}HuH}HuH}HuH}HuH}HutwH}HutfH}HutUEMU]emu}LHuHH1HH[A^A_]E1Mf.fUHAWAVSH8HuHjHED~D}HG]ĉ]ȅyHHLw(MA)H}AHuH}HutyH}HuthH}HutWH}HutFEMU]eLHuHH1H8[A^A_]E1M;f.@UHAWAVSH8HuHjHED~D}HG]ĉ]ȅyHHLw(MA)H}AHuH}HuH}Hut~H}HutmH}Hut\H}HutKEMU]emLHuHH1H8[A^A_]E1M!@UHAVSH@^HG)Ѓ[ HuHjHE]ȉỦUЅyHHH_(HHuH}HuH}H5 H}HU}EMHHWHuHiHE]ȉỦUЅyHH\H_(HEH9H5H}HUHt9IH5vH}HU}tHLHH 1H}HHHuHIiHE]ȉỦUЅyHHH_(HH}HutzH}HutiH}HutXH5H}HU}t>EMUHHHuHHH5h1HH@[A^]HE1HRHHH}Hf.DUHAWAVATSH0HuHiHEDvDuHG]ĉ]ȅyHHLg(MA)H}AHuH}HuH5H}HU}tqIH5hH}HU}tTIH}Hut@EM؋MLLLHuHH1H0[A\A^A_]E1M#@UHHHHGzu H=]H5i1]@UHHHHGzu H=]H5k1]f.DUHHHHGzu H=]H5l1]@UHAWAVSHXHHHEHuHoHED~D}HG]]yHHLw(HEMA)H}AHuH}Huк(E)EHuHULE.Eu)z'E.EuzE.Euz E.Eu{!HuH}HUоHuHH1H H H;Mu!HX[A^A_]E1HEMfUHAWAVSHHHuHoHED~D}HG]]yHHLw(W)EHEMtmA)AuQH}HutSH}HutBH}Hut1}EMtHHuLFH}1Et H}HHH[A^A_]E1XHuLHuHcHEtHEt H}H f.UHAVSH`HHZHG)σxHUH=pH}]MĉMȅyHHHH`H^(W)EHEHtKH5GH}HU}t1IH}HutHUHLH1HUH={oH}]MĉMȅyHHHHH^(W)EHE)EHEHthH}HutWH}HutFH}Hut5H}Hut$EMHuHUHHtv1EtSH}HH=H`[A^]H5n13W)EHE11'HHEt H}HH`[A^]HHEtHEtH}HEt H}H f.UHAVSH HuHqHEDvDuHG]]y HHtH(HtD9uHt1H}111 HHH [A^]f.UHAWAVSH(HuHqHED~D}HG]ԉ]؅y HHt`Lw(MtWA)Au;H5H}HU}t4LHHuHHH}1H([A^A_]fUHAVSH HuHqHEDvDuHG]]y HHt H(HtD9uHHt1H}111 HHHH [A^]f.fUHAWAVSH(HuHLrHED~D}HG]ԉ]؅y HHt`Lw(MtWA)Au;H5n~H}HU}t4LHHuHHH}1H([A^A_]fUHAVSH HuHrHEDvDuHG]]y HHt H(HtD9uHHt1H}111 HHHH [A^]f.fUHAWAVSH(HuHrHED~D}HG]ԉ]؅y HHt`Lw(MtWA)Au;H5}H}HU}t4LHHuHHH}1H([A^A_]fUHAVSH HuH#sHEDvDuHG]]y HHt H(HtD9uHHt1H}111 HHHH [A^]f.fUHAWAVSH(HuH sHED~D}HG]ԉ]؅y HHt`Lw(MtWA)Au;H5{H}HU}t4LHHuHHH}1H([A^A_]fUHAVSH HuHrsHEDvDuHG]]y HHt H(HtD9uHHt1H}111 HHHH [A^]f.fUHAWAVSH(HuH\sHED~D}HG]ԉ]؅y HHt`Lw(MtWA)Au;H5gzH}HU}t4LHHuHHH}1H([A^A_]fUHAVSH HuHtHEDvDuHG]]y HHtH(HtD9uHt1H}111 HHHH [A^]UHAVSH HuH*tHEDvDuHG]]y HHtH(HtD9uHt1H}111 HHHH [A^]UHAWAVSH(HuH7tHED~D}HG]ԉ]؅y HHtXLw(MtOA)Au3HuH}t5HuLHuHHH}1H([A^A_]ÐUHH0HuHsHEFEHEH}؃u)HutEEHt1H0]þ1H0]W1M.H {)X ,HcH0]@UHAVSH HuHtHEDvDuHG]]y HHt!H(HtD9uEt#H_HHt+12H}111!HHHuHHHH [A^]DUHAWAVSH(HuH.tHED~D}HG]ԉ]؅y HHt\Lw(MtSA)Au7H5vH}HU}t0}t7LHHu9H}1H([A^A_]ILHHuHHUHAWAVSHHHHHEHuH<HED~D}HG]]yHHLw(MA)H}AupHuкtm(E)EHuLE.Eu)z'E.EuzE.Euz E.Eu{ Ht8HuJ1H H H;MuCHH[A^A_]H}HU1HuHHH H H;MtUHAWAVSH(HuH;HED~D}HG]ԉ]؅y HHt`Lw(MtWA)Au;H5rH}HU}t4LHHuHHH}1H([A^A_]fUHAWAVATSH0HuH@HEDvDuHG]̉]ЅyHHLg(MA)Au{H5vrH}HU}ttIH5rH}HU}tWIH5IrH}HU}t:LLLHHuHHH}1H0[A\A^A_]f.UHAWAVAUATSHHHuH?HEFEHGMĉMȅyHHL(H}AC6HcH}Lm1EIcMdLDM?E+EăH5*qH}HU}HH}LDH}HuHDEArIDI9II91HHHHHtf.A|AHEFEHGMMyHHL(EH}AC6HcH}Le1EIcM,LDM7E+EH}HuH}HuH}LDH}HuDEArII9IDI91HHHHHt@A4AtHHuHoA ALALALALALAL AL ALALALALALALALALHH9uH}1H}HEH9t HtHHX[A\A]A^A_]E1V؃HpHHH‰уHs1qHH)1AALADALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpH HuHt+HHADA ADALH HuH9`}ůEDEtLLMLLAE~:1AA.Du z HH9uHuH}LDHHHH}HEH9uzHH}HEH9t HtH fUHAWAVSH(HuH*;HEDvDuHG]ԉ]؅yHHL(EMA)AHuH}H}HuH5iH}HU}tzIH5jH}HU}t]}uMt2LLI4H}1)E1!ILLIHt 1H([A^A_]HHf.UHAWAVAUATSHHuHH@HEFEHGMMyHHHG(HELeE1L1ÍHcHPLPH]HcILELÍHcHpLpE1H]HcIIDH}3E+EH}LHU H}LHUH}HuHEȉDž}rII9II91HHHHHtf.A4A4HHuHfDA A ALALALALAL AL ALALALALALALALALHH9u6H}E1HpHxH9t HtHPHXH9t HtLHĈ[A\A]A^A_]1HpHHH‰уHs1pHH)1AALAALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpH HuHt*HHADA ADA H HuH91H}HEAŅp}rKH9JI91HHLLHtA44HHuHA ALLALLAL L ALLALLALLALLHI9uDHpHHH‰уHs1hHH)1AALLAD AL0D L0AD@ALPD@LPAD`ALpD`LpH HuHt(HHADA D H HuL9MH}LLHM}~D1f.AA.u z HH9uHuH}1LHM}~<1A.u z HI9uHuH}LHMHL-IEHpHxH9HHpHxH9tHt HHPHXH9t HtH fDUHAWAVAUATSH8HuHk:HEFEHGMĉMȅyHHL(H}AC6HcH}LmMcM1ELDME+EăH5bH}HU}HH}LDH}HuHDEA rIDI9II91HHHHHt!f.DALA HHuHK@ALA ALALALALALALHH9uH}1H}HEH9t HtHH8[A\A]A^A_]E1u؃HxHHH‰уH`s1qHH)1ADALAALAD AL0AD AL0AD@ALPAD@ALPAD`ALpAD`ALpHHuHt'HHADALADA H HuH9xMLLE~:1@ALA: u HH9uHuH}LDHHHH}HEH9HH}HEH9t HtH f.UHAWAVSHHHuHDHEDvDuHG]]yHHL(W)EHEMtuA)AuYH5u_H}HU}tRIH}Hut>HULLHu%HHEu$H}1Et H}HHH[A^A_]W)EHE1EtHEt H}H UHAWAVSHHHuHBHEDvDuHG]]yHHL(H}MtuA)AuYH5K^H}HU}tRIH}Hut>HULLHu%HHEu$H}1Et H}HHH[A^A_]E1H}MWHEt H}H fUHAWAVSHHHuHrCHEDvDuHG]]yHHL(W)EHEMtuA)AuYH5]H}HU}tRIH}Hut>HULLHu%HHEu$H}1Et H}HHH[A^A_]W)EHE1EtHEt H}H UHAWAVSHHHuHBBHED~D}HG]]yHHLw(W)EHEMA)AueH}HutgH}HutVH}HutEEMHuLHu%HHEu$H}1Et H}HHH[A^A_]E1@HEt H}H fUHAWAVSHHHuHAHEDvDuHG]]yHHL(H}MtuA)AuYH5ZH}HU}tRIH}Hut>HULLHu%HHEu$H}1Et H}HHH[A^A_]E1H}MWHEt H}H fUHAWAVSHHHuH?HED~D}HG]]yHHLw(H}Mt{A)Au_H}HutaH}HutPH}Hut?EMHuLHuHHH}1Et H}HHH[A^A_]E1H}MQHEt H}H UHAWAVSHHHuH@HED~D}HG]]yHHLw(W)EHEMtrA)AuVH}HutXH5DXH}HU}t>HuLHHu%HHEu$H}1Et H}HHH[A^A_]W)EHE1EtHEt H}H @UHAWAVSHhHHHEHuHO?HED~D}HG]]yHH#Lw(W)EHEMA)AH}HuH}Huк(E)EHuHULE.Eu)z'E.EuzE.Euz E.Eu{!HuH}HUоHu%HHEu$H}1Et H}HHH;EuHHh[A^A_]E1HEt H}H UHAWAVSHHHuH=HED~D}HG]]yHHLw(H}MtlA)AuPH}HutRH5jUH}HU}t8HuLHHuHHH}1Et H}HHH[A^A_]E1H}M`HEt H}H fUHAWAVSHhHHHEHuH<HED~D}HG]]yHHLw(H}MA)AH}HuH}Huк(E)EHuHULE.Eu)z'E.EuzE.Euz E.Eu{!HuH}HUоHuHHH}1Et H}HHH;Eu%HHh[A^A_]E1H}MHEt H}H DUHAWAVSHHHuHAHED~D}HG]]yHHLw(W)EHEMA)AueH}HutgH}HutVH}HutEEMHuLHu%HHEu$H}1Et H}HHH[A^A_]E1@HEt H}H fUHAWAVSHhHuH]@HEDvDuHG]]yHHL(W)EHE)EHEMA)AunH5eQH}HU}tgIH}HutSH}HutBHUHMLLHu%HHEu$H}1Et H}Et H}HHh[A^A_]E1HEuEuH H}EtH}H g'  =   X   J$MG  =' J})  v  r6      rx$Ms'! ! !X! ! ! ! ! o ! !  J!!  oo/  )BgcMM   ~MoolTiilRoolTssxCiilRiirRooiTXiicRgssxCq;ݜHDW]{آܢCUK[Xawp{ʲenWcIU#-޺0@"/Q` rBV%.s$4@J-8M)0AHvtkContext2DvtkRenderingContext2DPython.vtkContext2DvtkContext2D - 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. 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) -> vtkContext2D C++: static vtkContext2D *SafeDownCast(vtkObjectBase *o) NewInstanceV.NewInstance() -> vtkContext2D C++: vtkContext2D *NewInstance() BeginV.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. GetDeviceV.GetDevice() -> vtkContextDevice2D C++: virtual vtkContextDevice2D *GetDevice() EndV.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. GetBufferIdModeV.GetBufferIdMode() -> bool C++: bool GetBufferIdMode() Tell if the context is in BufferId creation mode. Initial value is false. BufferIdModeBeginV.BufferIdModeBegin(vtkAbstractContextBufferId) C++: void BufferIdModeBegin(vtkAbstractContextBufferId *bufferId) Start BufferId creation Mode. \pre not_yet: !GetBufferIdMode() \pre bufferId_exists: bufferId!=0 \post started: GetBufferIdMode() BufferIdModeEndV.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() DrawLineV.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. DrawPolyV.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. DrawLinesV.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() DrawPointV.DrawPoint(float, float) C++: void DrawPoint(float x, float y) Draw a point at the supplied x and y coordinate DrawPointsV.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 DrawPointSpritesV.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. DrawMarkersV.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. DrawRectV.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 DrawQuadV.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). DrawQuadStripV.DrawQuadStrip(vtkPoints2D) C++: void DrawQuadStrip(vtkPoints2D *points) V.DrawQuadStrip([float, ...], int) C++: void DrawQuadStrip(float *p, int n) Draw a strip of quads DrawPolygonV.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 DrawEllipseV.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 DrawWedgeV.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 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) 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 DrawArcV.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 DrawEllipticArcV.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 DrawImageV.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). DrawPolyDataV.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. DrawStringRectV.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. DrawStringV.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. ComputeStringBoundsV.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. ComputeJustifiedStringBoundsV.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. ComputeFontSizeForBoundedStringV.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. DrawMathTextStringV.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. MathTextIsSupportedV.MathTextIsSupported() -> bool C++: bool MathTextIsSupported() Return true if MathText rendering available on the current device. ApplyPenV.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. GetPenV.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. ApplyBrushV.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. GetBrushV.GetBrush() -> vtkBrush C++: vtkBrush *GetBrush() Get the pen which controls the outlines of shapes as well as lines, points and related primitives. ApplyTextPropV.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. GetTextPropV.GetTextProp() -> vtkTextProperty C++: vtkTextProperty *GetTextProp() Get the text properties object for the vtkContext2D. SetTransformV.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. GetTransformV.GetTransform() -> vtkTransform2D C++: vtkTransform2D *GetTransform() Compute the current transform applied to the context. AppendTransformV.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. PushMatrixV.PushMatrix() C++: void PushMatrix() Push/pop the transformation matrix for the painter (sets the underlying matrix for the device when available). PopMatrixV.PopMatrix() C++: void PopMatrix() Push/pop the transformation matrix for the painter (sets the underlying matrix for the device when available). ApplyIdV.ApplyId(int) C++: void ApplyId(vtkIdType id) Apply id as a color. FloatToIntV.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. GetContext3DV.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. SetContext3DV.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. vtkObjectvtkObjectBasevtkContextDevice2DvtkAbstractContextBufferId@P *f@V *vtkPoints2DvtkPoints2D@VVV *vtkImageData *vtkPoints2D *vtkUnsignedCharArray@VPi *vtkImageData *fvtkImageDatavtkUnsignedCharArray@iqPi *f@iqVV *vtkPoints2D *vtkUnsignedCharArray@PPi *f *f@VPi *vtkPoints2D *BvtkRectfvtkPolyData@Vs *vtkPoints2D@Vu *vtkPoints2D@ffs@ffu@sV *vtkPoints2D@sP *f@uV *vtkPoints2D@uP *f@Vss *vtkPoints2DvtkPenvtkBrushvtkTextPropertyvtkTransform2DvtkContext3DOP `!a!`!`a !!p!a!`% XAXAa` XA$%XApp,?XA3a4XA܎`9XA`=XA$pNaO<aPta@R"apS<aT!PW< X<XA Y<`YwaZCaA0\V!A^!0_a_!`aPa!aab!Pcad!dape!f!fa@gg!hapiOajak lzXApXAsCatXAzFXA4 ~/aALP'aA`/aAt.aA'aA-aA@,aAĐpaAؐ aA@aA.aA qaA,zRx $(OAC $DP AC $l8AC B$AC G$(AC I$AC G$ AC G$4pAC I$\AC G$AC G$AC G$AC I$AC G$$%AC E$L0AC I$tHAC I$cAC I$d<AC I$etAC I$pf"AC I$<xg<AC I$dhAC G,k<AC K$l<AC $0lAAC $ Xl<AC $4plwAC I$\xqAC G$qAC I$rAC G$sAC I$sAC G$$tAC I$LtAC G$t uAC I$uAC G$0vAC I$vAC G$0wAC G$<wAC I$d xAC $xAC G$ yAC I$yOAC I${AC I,,{AC K$\CAC IzPLRx 4$0 #AC P4\&WAC M4+ CAC P4x4WAC P40;?OAC P4<HCSAC M4tG?AC M4xK+AC P,hCkAC I,iV_AC G4DzzOAC M4|X}/AC M4AC P4FAC M,$/ۜAC I,T'AC I,/AC I,.AC I,'kAC I,-OAC I,D,3AC I,tAC I,@AC I,0AC I,.ǛAC I,4qAC I--t-i-<----=o--֌-Ō--^-4---׋-=o---}-l-.--݊-ˊ--=--h=\o-W-;o---ȉ---bP=8-0----Ј=Ĉo----w-^-4- --ԇ=͇--=o--qo-8----=f-^-%--=o--Ѕ-Å-~-T7-/----τ=Äo-----g-N-$--܃-ƒ--=o--o-Y-L7--؂-Ђ---y=mo-h-N-=-,--ā--h-W-9=-o-(----q-i-L-2-!-=o------dI-A--~-~=~o-~-~-~-~^~-4~~-~-}=}o-}-}o-}-|-x|-{-{-{-s{A{-.{-{-zz-z-z-Xz=Hzo-Cz-)zo-z-yo-y-8w-w-v-v-v-u-u-u-lu-Xu-3u- ut=to-t-t-ct-VtFt-9t*t-t-s-ss-s-]s=Mso-Hs-/so-r-q-q-p-p-p-p-p-rp-Pp-(pp-o-o=oo-o-oo-io-un-\n-sm-^m-Bm-5mm-l-l-lpl-Xl=Llo-Gl-0l-#ll-lk-kk-kfk-Nk=Bko-=k-,k-kj-jj-j=j=jo-j-jj=aj-Kjo-Ajo-j-i-i-ii=_i=Sio-2i-io-i-h-hh-hxh-kho-Xh-@ho-h-ggp-gg-go-sg-Og.g-g= go-g-f-f-f}f=tf-\fo-Wf-e=2eo--e-e-ed-dd-d-odo-gd-Ld-"dc-c=co-c-c-cc-dc1c-'c-co-c-b-bb-~b=rbo-mb-\b-Ob.b-ba-a-ao-a-a-ba6a-a=ao- a-`-``-`q`-g`-O`o-G`-,`-`_-_=_o-_-_-_n_-D__m-_-^o-^-^-^^-x^-d^-G^=4^-"^=]-]]-]5]-]o-]-]-]-]-o]-2]-]\o-\-\-\-\\-y\\-\-[p-[o-[-[-[-[-z[-i[-X[-[-ZZ-Z=Z-Z={Zo-vZ-ZZo-!Z-Z-Y-Y-YpY=TY-OYHY-BY0 Y-YX-X.X-XX-X,kX-WX=KXo-FX-'X-X-XW-WW-W-W-fW+W=V-VV=Vo-V-V-VV-V-V-[V-EV5V-Vo- V-U-UU-UU-UU-`U-SUDU-/U- U-TT-yT=mTo-hT->T--T-T- T-S-S-S-SCS-/S=#So-S-R-R-R-R-R-~R-TRR-R=Qo-Q-Q-Q-Q-Q-pQ-[Q-FQ-1Q-P-PP-P=}Po-xP-NP-=P-,P-P-P-O-O-OUO-AO=5Oo-0O-O-N-N-N-N-NVN-NN-&N-M-M=Mo-M-xMo-TM-9Mo- M-Lo-L-I=Io-I-Ho-H-Ho-H-E=Eo-E-Eo-E-D-D-iD-ID-1D-C-+C-C-B-B-B-B-fB-=B-%B-B-A-A-A@-@-@-@-V@-B@-@- @-?-??-?">->->-~>-`>-D>1>-,>>=>o- >-=-==-=Q=-I=-===o-=-<o-<-;-;-;-;:-:-f:-S:-6:- : :=9o-9-9-99-9K9-C9-9=8-8o-8-8o-8-7-7-76-6-j6-L6-66"6=6o- 6-5-5-5-5-~5-i5-T5-?5-5-54-4=u4o-p4-P4-?4-.4-4-3-33-3-}3-I3=93o-43-3o-2-2o-2-/=/o-Y/-=<xh;`XH:@8(9 87421xh/`XH-@8(+ *)('&xh%`XH$@8(! xh`XH@8(     xh `XH@8( @q8|{wsrX}0yu   xp`XP@80 xp`@80 `@ `@ xp`@ `@ xp`XP@80 `@ `@ M\NPcP;!``N py>`Pv #a#%`2#$/%"pp,"|34b$܎[`9)$`=>p#$pNhOPW@RpSTPWXКFXg0 Y Л`YZ#r0\pk#^0_;_`Paa.bcPcddpef.fP@g gh]pijklX#Zp#st"`z$4 ~O$L'P$`%#t#~#-E#@ #Đp"ؐ\ "@$&<$ $,`9   6rF sR4X D !# * 0!2 ^   T   Dq!jX *"!~  H"+    {D J ]m ~"V d! !  w ML^!  v NK@:=I# T-  7ku$\__ZN12vtkContext2D13ApplyTextPropEP15vtkTextProperty_PyType_Ready__ZN12vtkContext2D11DrawMarkersEibP11vtkPoints2DP20vtkUnsignedCharArray__ZN12vtkContext2D16DrawPointSpritesEP12vtkImageDataP11vtkPoints2DP20vtkUnsignedCharArray__ZN13vtkPythonArgs8GetValueERx__ZN12vtkContext2D7ApplyIdEx_PyvtkObject_ClassNew_PyvtkContext2D_ClassNew_PyVTKObject_New__ZL24PyvtkContext2D_StaticNewv__ZdlPv__ZdaPv__ZN12vtkContext2D9PopMatrixEv__ZN12vtkContext2D10PushMatrixEv__ZN12vtkContext2D3NewEv__ZN12vtkContext2D11GetTextPropEv__ZN12vtkContext2D6GetPenEv__ZN12vtkContext2D12GetTransformEv__ZN12vtkContext2D8GetBrushEv__ZNK12vtkContext2D15GetBufferIdModeEv__ZN12vtkContext2D15BufferIdModeEndEv__ZN12vtkContext2D3EndEv__ZN12vtkContext2D19MathTextIsSupportedEv__ZN16vtkUnicodeStringC1Ev_PyVTKObject_GetSet__Py_NoneStruct__ZN13vtkPythonArgs21GetArgAsSpecialObjectEPKcPP7_object_PyVTKObject_GetObject__ZL37PyvtkContext2D_DrawStringRect_Methods__ZL34PyvtkContext2D_DrawMarkers_Methods__ZL39PyvtkContext2D_DrawPointSprites_Methods__ZL42PyvtkContext2D_ComputeStringBounds_Methods__ZL34PyvtkContext2D_DrawPolygon_Methods__ZL33PyvtkContext2D_DrawString_Methods__ZL41PyvtkContext2D_DrawMathTextString_Methods__ZL31PyvtkContext2D_DrawLine_Methods__ZL22PyvtkContext2D_Methods_PyObject_GenericSetAttr_PyObject_GenericGetAttr_PyVTKObject_Repr_PyVTKObject_AsBuffer_strcmp__ZN12vtkContext2D8ApplyPenEP6vtkPen___stack_chk_fail_PyObject_GC_Del__ZN13vtkPythonArgs5ArrayIhEC1El__ZN13vtkPythonArgs5ArrayIfEC1El_PyVTKObject_Check__ZN12vtkContext2D12DrawPolyDataEffP11vtkPolyDataP20vtkUnsignedCharArrayi__ZN13vtkPythonArgs13ArgCountErrorEii__ZN12vtkContext2D11DrawMarkersEibPfiPhi__ZN12vtkContext2D16DrawPointSpritesEP12vtkImageDataPfiPhi__ZN12vtkContext2D8DrawPolyEPfiPhi__ZN12vtkContext2D11DrawPolygonEPfiPhi__ZN12vtkContext2D11DrawPolygonEPfS0_iPhi__ZN13vtkPythonArgs8GetArrayEPhi__ZN12vtkContext2D11DrawPolygonEP11vtkPoints2DPhi__ZN13vtkPythonArgs8SetArrayEiPKhi__ZN12vtkContext2D11DrawMarkersEibPfi__ZN12vtkContext2D16DrawPointSpritesEP12vtkImageDataPfi__ZN12vtkContext2D8DrawPolyEPfi__ZN13vtkPythonArgs8GetArrayEPfi__ZN12vtkContext2D10DrawPointsEPfi__ZN12vtkContext2D9DrawLinesEPfi__ZN12vtkContext2D13DrawQuadStripEPfi__ZN12vtkContext2D11DrawPolygonEPfi__ZN13vtkPythonArgs8SetArrayEiPKfi__ZN12vtkContext2D8DrawPolyEPfS0_i__ZN12vtkContext2D10DrawPointsEPfS0_i__ZN12vtkContext2D11DrawPolygonEPfS0_i__ZN13vtkPythonArgs8GetValueERi__ZN13vtkPythonArgs10GetArgSizeEi__ZN12vtkContext2D10ApplyBrushEP8vtkBrush_PyBool_FromLong_PyLong_FromLong_PyDict_SetItemString__ZN13vtkPythonArgs8GetValueER16vtkUnicodeString__ZN12vtkContext2D10DrawStringEffRK16vtkUnicodeString__ZN12vtkContext2D14DrawStringRectEP11vtkPoints2DRK16vtkUnicodeString__ZN12vtkContext2D10DrawStringEP11vtkPoints2DRK16vtkUnicodeString__ZN12vtkContext2D10DrawStringEffRK12vtkStdString__ZN12vtkContext2D18DrawMathTextStringEffRK12vtkStdString__ZN12vtkContext2D14DrawStringRectEP11vtkPoints2DRK12vtkStdString__ZN12vtkContext2D10DrawStringEP11vtkPoints2DRK12vtkStdString__ZN12vtkContext2D18DrawMathTextStringEP11vtkPoints2DRK12vtkStdString_PyVTKObject_String_PyVTKObject_SetFlag__ZN12vtkContext2D31ComputeFontSizeForBoundedStringERK12vtkStdStringff__ZN12vtkContext2D16DrawEllipseWedgeEffffffff__ZN12vtkContext2D8DrawQuadEffffffff__ZN12vtkContext2D9DrawWedgeEffffff__ZN12vtkContext2D15DrawEllipticArcEffffff__ZN12vtkContext2D7DrawArcEfffff__ZN12vtkContext2D8DrawRectEffff__ZN12vtkContext2D11DrawEllipseEffff__ZN12vtkContext2D8DrawLineEffff__ZN12vtkContext2D9DrawPointEff__ZN13vtkPythonArgs8GetValueERf__ZN12vtkContext2D19ComputeStringBoundsERK16vtkUnicodeStringPf__ZN12vtkContext2D19ComputeStringBoundsERK12vtkStdStringPf__ZN12vtkContext2D28ComputeJustifiedStringBoundsEPKcPf__ZN12vtkContext2D8DrawLineEPf__ZN12vtkContext2D8DrawQuadEPf_PyVTKObject_Delete_PyVTKObject_Traverse__ZN13vtkPythonUtil20GetObjectFromPointerEP13vtkObjectBase_PyType_Type__ZL19PyvtkContext2D_Type__Unwind_Resume___stack_chk_guard_PyErr_Occurred_PyVTKClass_Add__ZN12vtkContext2D17BufferIdModeBeginEP26vtkAbstractContextBufferId__Py_Dealloc__ZN13vtkPythonArgs8GetValueERPc__ZN13vtkPythonArgs13ArgCountErrorEiPKc__ZN13vtkObjectBase8IsTypeOfEPKc__ZN13vtkPythonArgs17GetArgAsVTKObjectEPKcRb__ZN13vtkPythonArgs8GetValueERb__ZN12vtkContext2D9DrawImageERK8vtkRectfP12vtkImageData__ZN12vtkContext2D9DrawImageEfffP12vtkImageData__ZN12vtkContext2D9DrawImageEffP12vtkImageData__ZN12vtkContext2D18DrawMathTextStringEP11vtkPoints2DRK12vtkStdStringS4___ZN17vtkPythonOverload10CallMethodEP11PyMethodDefP7_objectS3___ZN12vtkContext2D18DrawMathTextStringEffRK12vtkStdStringS2___ZN13vtkPythonArgs19GetSelfFromFirstArgEP7_objectS1___ZL23PyvtkContext2D_DrawPolyP7_objectS0___ZL24PyvtkContext2D_PopMatrixP7_objectS0___ZL25PyvtkContext2D_PushMatrixP7_objectS0___ZL27PyvtkContext2D_SafeDownCastP7_objectS0___ZL24PyvtkContext2D_DrawPointP7_objectS0___ZL25PyvtkContext2D_FloatToIntP7_objectS0___ZL23PyvtkContext2D_DrawRectP7_objectS0___ZL29PyvtkContext2D_DrawStringRectP7_objectS0___ZL25PyvtkContext2D_DrawPointsP7_objectS0___ZL26PyvtkContext2D_DrawMarkersP7_objectS0___ZL31PyvtkContext2D_DrawPointSpritesP7_objectS0___ZL24PyvtkContext2D_DrawLinesP7_objectS0___ZL34PyvtkContext2D_ComputeStringBoundsP7_objectS0___ZL43PyvtkContext2D_ComputeJustifiedStringBoundsP7_objectS0___ZL28PyvtkContext2D_ApplyTextPropP7_objectS0___ZL26PyvtkContext2D_GetTextPropP7_objectS0___ZL28PyvtkContext2D_DrawQuadStripP7_objectS0___ZL26PyvtkContext2D_DrawPolygonP7_objectS0___ZL32PyvtkContext2D_BufferIdModeBeginP7_objectS0___ZL20PyvtkContext2D_BeginP7_objectS0___ZL23PyvtkContext2D_ApplyPenP7_objectS0___ZL21PyvtkContext2D_GetPenP7_objectS0___ZL27PyvtkContext2D_SetTransformP7_objectS0___ZL27PyvtkContext2D_GetTransformP7_objectS0___ZL30PyvtkContext2D_AppendTransformP7_objectS0___ZL25PyvtkContext2D_ApplyBrushP7_objectS0___ZL23PyvtkContext2D_GetBrushP7_objectS0___ZL25PyvtkContext2D_DrawStringP7_objectS0___ZL33PyvtkContext2D_DrawMathTextStringP7_objectS0___ZL46PyvtkContext2D_ComputeFontSizeForBoundedStringP7_objectS0___ZL23PyvtkContext2D_IsTypeOfP7_objectS0___ZL26PyvtkContext2D_DrawEllipseP7_objectS0___ZL23PyvtkContext2D_DrawLineP7_objectS0___ZL24PyvtkContext2D_DrawWedgeP7_objectS0___ZL31PyvtkContext2D_DrawEllipseWedgeP7_objectS0___ZL24PyvtkContext2D_DrawImageP7_objectS0___ZL30PyvtkContext2D_GetBufferIdModeP7_objectS0___ZL26PyvtkContext2D_NewInstanceP7_objectS0___ZL24PyvtkContext2D_GetDeviceP7_objectS0___ZL30PyvtkContext2D_BufferIdModeEndP7_objectS0___ZL18PyvtkContext2D_EndP7_objectS0___ZL34PyvtkContext2D_MathTextIsSupportedP7_objectS0___ZL23PyvtkContext2D_DrawQuadP7_objectS0___ZL22PyvtkContext2D_ApplyIdP7_objectS0___ZL22PyvtkContext2D_DrawArcP7_objectS0___ZL30PyvtkContext2D_DrawEllipticArcP7_objectS0___ZL27PyvtkContext2D_DrawPolyDataP7_objectS0___ZL27PyvtkContext2D_SetContext3DP7_objectS0___ZL27PyvtkContext2D_GetContext3DP7_objectS0___ZL18PyvtkContext2D_IsAP7_objectS0___ZL29PyvtkContext2D_DrawPolygon_s5P7_objectS0___ZL29PyvtkContext2D_DrawMarkers_s4P7_objectS0___ZL34PyvtkContext2D_DrawPointSprites_s4P7_objectS0___ZL37PyvtkContext2D_ComputeStringBounds_s4P7_objectS0___ZL28PyvtkContext2D_DrawString_s4P7_objectS0___ZL37PyvtkContext2D_ComputeStringBounds_s3P7_objectS0___ZL28PyvtkContext2D_DrawString_s3P7_objectS0___ZL36PyvtkContext2D_DrawMathTextString_s3P7_objectS0___ZL26PyvtkContext2D_DrawLine_s3P7_objectS0___ZL32PyvtkContext2D_DrawStringRect_s2P7_objectS0___ZL29PyvtkContext2D_DrawMarkers_s2P7_objectS0___ZL34PyvtkContext2D_DrawPointSprites_s2P7_objectS0___ZL37PyvtkContext2D_ComputeStringBounds_s2P7_objectS0___ZL28PyvtkContext2D_DrawString_s2P7_objectS0___ZL36PyvtkContext2D_DrawMathTextString_s2P7_objectS0___ZL26PyvtkContext2D_DrawLine_s2P7_objectS0___ZL32PyvtkContext2D_DrawStringRect_s1P7_objectS0___ZL37PyvtkContext2D_ComputeStringBounds_s1P7_objectS0___ZL29PyvtkContext2D_DrawPolygon_s1P7_objectS0___ZL28PyvtkContext2D_DrawString_s1P7_objectS0___ZN13vtkPythonArgs8GetValueERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE__ZN12vtkContext2D12SetContext3DEP12vtkContext3D_PyVTKAddFile_vtkContext2D__ZN12vtkContext2D19ComputeStringBoundsERK16vtkUnicodeStringP11vtkPoints2D__ZN12vtkContext2D19ComputeStringBoundsERK12vtkStdStringP11vtkPoints2D__ZN12vtkContext2D11DrawMarkersEibP11vtkPoints2D__ZN12vtkContext2D16DrawPointSpritesEP12vtkImageDataP11vtkPoints2D__ZN12vtkContext2D8DrawPolyEP11vtkPoints2D__ZN12vtkContext2D10DrawPointsEP11vtkPoints2D__ZN12vtkContext2D9DrawLinesEP11vtkPoints2D__ZN12vtkContext2D13DrawQuadStripEP11vtkPoints2D__ZN12vtkContext2D11DrawPolygonEP11vtkPoints2D__ZN12vtkContext2D8DrawLineEP11vtkPoints2D__ZN12vtkContext2D12SetTransformEP14vtkTransform2D__ZN12vtkContext2D15AppendTransformEP14vtkTransform2D__ZN12vtkContext2D5BeginEP18vtkContextDevice2DGCC_except_table69GCC_except_table59GCC_except_table19GCC_except_table68GCC_except_table18GCC_except_table67GCC_except_table57GCC_except_table17GCC_except_table66GCC_except_table56GCC_except_table36GCC_except_table65GCC_except_table35GCC_except_table15GCC_except_table64GCC_except_table14GCC_except_table63GCC_except_table23GCC_except_table72GCC_except_table62GCC_except_table22GCC_except_table71GCC_except_table61GCC_except_table21___gxx_personality_v0GCC_except_table70GCC_except_table60