by critor » 01 May 2020, 12:28
by critor » 01 May 2020, 13:50
Avant l'avènement des calculatrices graphiques, c'est 
by critor » 02 May 2020, 15:32
Dans un article précédent te finalisait une version 
Mais voilà, la technologie Pas de redimensionnement réduisant la qualité du rendu ici, le rendu était tout simplement tronqué. Il te manquait 8 lignes de pixels en haut d'écran, ce qui pouvait notamment se remarquer sur les fonds d'écran.
Mais est de retour aujourd'hui avec une nouvelle version 
by critor » 03 May 2020, 09:55
by critor » 03 May 2020, 16:26
Cette dernière application apporte de nouveaux modules importables pour tes scripts 2ndeou
alpha)
L'appel 
def sizeenv():
s=0
import __main__
for o in dir(__main__):
try:s+=size(eval(o))
except:pass
return s
def size(o):
s,t=0,type(o)
if t==str:s=49+len(o)
if str(t)=="<class 'function'>":s=136
if t==int:
s=24
while o:
s+=4
o>>=30
if t==list:
s+=64
for so in o:s+=8+size(so)
return s
def mem(v=1,r=1):
try:
l=[]
try:
l+=[r and 793+sizeenv()]
if v*r:print(" ",l[0])
l+=[0]
l+=[""]
l[2]+="x"
while 1:
try:l[2]+=l[2][l[1]:]
except:
if l[1]<len(l[2])-1:l[1]=len(l[2])-1
else:raise(Exception)
except:
if v:print("+",size(l))
try:l[0]+=size(l)
except:pass
try:l[0]+=mem(v,0)
except:pass
return l[0]
except:return 0
Les formidables nouveautés de la version 
gc.mem_alloc() retourne l'espace occupé sur le tas gc.mem_free() retourne l'espace libre sur le tas from gc import *
a, f = mem_alloc(), mem_free()
(a, f, a+f)
Nous découvrons donc que le tas 
Grande nouveauté de l'application F3.
from gc import mem_free as mf
smod = input('Module : ')
mf1, mf2 = 0, 0
scmd = 'from ' + s + ' import *'
mf1 = mf()
exec(scmd)
mf2 = mf()
print(mf1 - mf2)
by critor » 03 May 2020, 22:37
Bien des difficultés en perspective, puisque 
by critor » 04 May 2020, 10:58
Cette dernière application apporte de nouveaux modules importables pour tes scripts 2ndeou
alpha)
def getplatform():
id=-1
try:
import sys
try:
if sys.platform=='nspire':id=0
if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4
except:id=3
except:
try:
import kandinsky
id=1
except:
try:
if chr(256)==chr(0):id=5+(not ("HP" in version()))
except:
id=2
return id
platform=getplatform()
#lines shown on screen
#plines=[29,12, 7, 9,11,0,0]
plines=[29,16, 7, 9,11,0,0]
#max chars per line
#(error or CR if exceeded)
pcols =[53,99,509,32,32,0,0]
nlines=plines[platform]
ncols=pcols[platform]
curline=0
def mprint(*ls):
global curline
st=""
for s in ls:
if not(isinstance(s,str)):
s=str(s)
st=st+s
stlines=1+int(len(st)/ncols)
if curline+stlines>=nlines:
input("Input to continue:")
curline=0
print(st)
curline+=stlines
def sstr(obj):
try:
s=obj.__name__
except:
s=str(obj)
a=s.find("'")
b=s.rfind("'")
if a>=0 and b!=a:
s=s[a+1:b]
return s
def isExplorable(obj):
s=str(obj)
return s.startswith("<") and s.find(" ")>=0 and not s.startswith("<module")
def explmod(pitm,pitmsl=[],reset=True):
global curline
if(reset):
curline=0
pitmsl=[sstr(pitm)]
hd="."*(len(pitmsl)-1)
spath=".".join(pitmsl)
c,c2=0,0
spitm=str(pitm)
for itms in sorted(dir(pitm)):
c,c2=c+1,c2+1
try:
itm=eval(spath+"."+itms)
mprint(hd+itms+"="+str(itm))
if isExplorable(itm) and itm!=pitm:
pitmsl2=pitmsl.copy()
pitmsl2.append(itms)
c2=c2+explmod(itm,pitmsl2,False)[1]
except:
mprint(hd+itms)
if c>0 and reset:
mprint(hd+"Total: "+str(c)+" 1st level item(s)")
if c2>0 and c2!=c:
mprint(hd+" "+str(c2)+" item(s)")
return [c,c2]
Casio Graph 35+E II 90+E | NumWorks | TI-83PCE Ed. Python | ||
builtins array collections cmath gc math matplotlib matplotlib.pyplot micropython os random sys time turtle uerrno | 84-175 . . . . 25 . . . . 8 . . . . | 97-440 3-13 . 13-17 9-13 42-46 . . 10-14 . . 17-63 . . 25-29 | 88-188 . . 12 . 41 3 11 6 . 9 . 3 38 . | 92-189 2-4 2 . 7 28 . . . . 8 15-42 4 . . |
spécifique | casioplot:6 | prime:3-7 | ion:48 kandinsky:6 | ti_graphics:30-45 ti_hub:? ti_plotlib:49-56 ti_system:12 ti_rover:? |
Modules | 4 | 9 | 11 | 13 |
Eléments | 123-214 | 219-642 | 265-365 | 249-397 |
Casio Graph 35+E II 90+E | MicroPython TI-Nspire | TI-Python | |||
builtins array collections cmath gc math matplotlib matplotlib.pyplot micropython os random sys time turtle uerrno | 84-175 . . . . 25 . . . . 8 . . 69 . | 91-204 2-4 . 12 7 41 . . 6 . 8 12 . . 24 | 93-218 2-4 . 12 7 41 . . 3 . . 15-45 . . . | 92-189 2-4 2 . 7 28 . . . . 8 15-42 4 . . | 93-191 2-4 2 12 7 41 . . 6 15 8 15-45 8-10 . . |
spécifique | casioplot:6 matplotl:25 | nsp:3-10 | board:22 storage:7-21 | ||
Modules | 6 | 9 | 8 | 9 | 13 |
Eléments | 217-308 | 203-318 | 176-340 | 158-284 | 238-384 |
getPixel(x, y)setPixel(x, y, c)
Quelles sont donc les dimensions de la zone graphique que nous contrôlons ?class polyscr:
w, h = 0, 0
# get_pixel(x, y)
# set_pixel(x, y, color(r8, g8, b8))
show_screen = lambda self: None
need_show_screen = False
# color mode :
# 0: (R8, G8, B8)
# 1: int RGB-565
color_mode = 0
def color(self, r, g=0, b=0):
if isinstance(r, tuple) or isinstance(r,list):
r, g, b = r[0], r[1], r[2]
return self.color_mode == 0 and (r,g,b) or r<<11 | g<<5 | b
def __init__(self):
try: # TI-Nspire Ndless
from nsp import Texture as myscr
self.w, self.h = 320, 240
myscr = myscr(self.w, self.h, None)
self.get_pixel = myscr.getPx
self.set_pixel = myscr.setPx
self.show_screen = myscr.display
self.need_show_screen = True
self.color_mode = 1
except:
try: # TI-83/84 CE
import ti_graphics as myscr
self.get_pixel = myscr.getPixel
self.set_pixel = myscr.setPixel
except ImportError:
try: # Casio USB Power Graphic 3
import casioplot as myscr
self.show_screen = myscr.show_screen
self.need_show_screen = True
except ImportError: # NumWorks
import kandinsky as myscr
self.get_pixel = myscr.get_pixel
self.set_pixel = myscr.set_pixel
# detect readable pixel array
if self.w <= 0:
def _can_get_pixel(x, y):
c = self.get_pixel(x, y)
if c == self.color(0, 0, 0):
self.set_pixel(x, y, self.color(255,0,0))
c = self.get_pixel(x, y)
return c is not None and c != self.color(0, 0, 0)
self.w, self.h, dw, dh = 0, 0, 1, 1
while dw or dh:
if not _can_get_pixel(self.w - (dw == 0),self.h - (dh == 0)):
if _can_get_pixel(self.w,self.h-1): dh = 0
elif _can_get_pixel(self.w-1,self.h): dw = 0
else: dw, dh = 0, 0
self.w += dw; self.h += dh
Appelons ensuite le code suivant pour obtenir la réponse :scr = polyscr()
print('can get {}x{} pixels at (0,0)'.format(scr.w, scr.h))
Sauf que... non, fausse joie. from ti_system import *
import ti_graphics as scr
for k in range(240):
sct.setPixel(k, k, (0, 0, 0))
disp_wait()class polyscr:
w, h, w0, h0, x0, y0 = 0, 0, 0, 0, 0, 0
# get_pixel(x, y)
# set_pixel(x, y, color(r8, g8, b8))
show_screen = lambda self: None
need_show_screen = False
# color mode :
# 0: (R8, G8, B8)
# 1: int RGB-565
color_mode = 0
def color(self, r, g=0, b=0):
if isinstance(r, tuple) or isinstance(r,list):
r, g, b = r[0], r[1], r[2]
return self.color_mode == 0 and (r,g,b) or r<<11 | g<<5 | b
def __init__(self):
try: # TI-Nspire Ndless
from nsp import Texture as myscr
self.w, self.h = 320, 240
myscr = myscr(self.w, self.h, None)
self.get_pixel = myscr.getPx
self.set_pixel = myscr.setPx
self.show_screen = myscr.display
self.need_show_screen = True
self.color_mode = 1
except:
try: # TI-83/84 CE
import ti_graphics as myscr
self.get_pixel = myscr.getPixel
self.set_pixel = myscr.setPixel
except ImportError:
try: # Casio USB Power Graphic 3
import casioplot as myscr
self.show_screen = myscr.show_screen
self.need_show_screen = True
except ImportError: # NumWorks
import kandinsky as myscr
self.get_pixel = myscr.get_pixel
self.set_pixel = myscr.set_pixel
# detect readable pixel array
if self.w <= 0:
def _can_get_pixel(x, y):
c = self.get_pixel(x, y)
if c == self.color(0, 0, 0):
self.set_pixel(x, y, self.color(255,0,0))
c = self.get_pixel(x, y)
return c is not None and c != self.color(0, 0, 0)
self.w, self.h, dw, dh = 0, 0, 1, 1
while dw or dh:
if not _can_get_pixel(self.w - (dw == 0),self.h - (dh == 0)):
if _can_get_pixel(self.w,self.h-1): dh = 0
elif _can_get_pixel(self.w-1,self.h): dw = 0
else: dw, dh = 0, 0
self.w += dw; self.h += dh
# detect writable pixel array
# remove top status bar
def _can_set_pixel(x, y):
def _invert_color(r, g=0, b=0):
if isinstance(r, tuple) or isinstance(r,list):
r, g, b = r[0], r[1], r[2]
return self.color(~r & 0xFF, ~g & 0xFF, ~b & 0xFF)
c = self.get_pixel(x, y)
self.set_pixel(x, y, _invert_color(c))
return c != self.get_pixel(x, y)
self.w0, self.h0 = self.w, self.h
while not _can_set_pixel(0, self.y0):
self.y0 += 1; self.h0 -= 1
Appelons enfin le code suivant pour obtenir toutes les informations écran :scr = polyscr()
print('can get {}x{} pixels at (0,0)'.format(scr.w, scr.h))
print('can set {}x{} pixels at ({},{})'.format(scr.w0, scr.h0, scr.x0, scr.y0))
Dans la version alpha qui a fuité pour prime.pixon(x, y, c) pour allumer les pixels.import prime as scr
def rect(x, y, w, h, c=(0,0,0)):
for k in range(w):
scr.pixon(x+k, y, c)
scr.pixon(x+k, y+h-1, c)
for k in range(h):
scr.pixon(x, y+k, c)
scr.pixon(x+w-1, y+k, c)
L'appel rect(0, 0, 320, 240, 255<<16) nous affiche bien un rectangle au complet et nous confirme donc que nous contrôlons ici la totalité des 320×240 pixels de l'écran.Comme vu plus haut avec les fonctions from polyscr import *
scr = polyscr()
def hsv2c(h,s,v):
c=v*s
x,m,k=c*(1-abs((h%(2/3))*3-1)),v-c,(h*3)//1
return (round(255*(m+x*(k%3==1)+c*(k%5==0))),round(255*(m+c*(k==1 or k==2)+x*(k%3==0))),round(255*(m+x*(k%3==2)+c*(k==3 or k==4))))
def grad(x,y,w,h):
for i in range(w):
for j in range(h):
c=hsv2c(2*j/(h-1),i>=w//2 and 1 or i/(w//2-1),i<w//2 and 1 or (w-1-i)/((w-w//2)-1))
scr.set_pixel(x+i,y+j,c)
L'appel suivant nous produit alors l'affichage ci-contre :grad(scr.x0, scr.y0, scr.w0, scr.h0)
Déjà pour information, on peut mesurer précisément le temps d'affichage à l'aide du script suivant. L'appel timer(grad, scr.x0, scr.y0, scr.w0, scr.h0) nous renvoie alors from time import monotonic
def timer(f, *par):
start=monotonic()
f(*par)
return monotonic()-startOr, remarquons un petit truc fort intéressant, une exclusivité à ce jour par rapport à la concurrence. Le module 
class polyscr:
w, h, w0, h0, x0, y0 = 0, 0, 0, 0, 0, 0
myscr = None
# get_pixel(x, y)
# set_pixel(x, y, color(r8, g8, b8))
show_screen = lambda self: None
need_show_screen = False
# color mode :
# 0: (R8, G8, B8)
# 1: int RGB-565
color_mode = 0
def color(self, r, g=0, b=0):
if isinstance(r, tuple) or isinstance(r,list):
r, g, b = r[0], r[1], r[2]
return self.color_mode == 0 and (r,g,b) or r<<11 | g<<5 | b
def __init__(self):
try: # TI-Nspire Ndless
from nsp import Texture as myscr
self.w, self.h = 320, 240
myscr = myscr(self.w, self.h, None)
self.get_pixel = myscr.getPx
self.set_pixel = myscr.setPx
self.show_screen = myscr.display
self.need_show_screen = True
self.color_mode = 1
except:
try: # TI-83/84 CE
import ti_graphics as myscr
self.get_pixel = myscr.getPixel
self.set_pixel = myscr.setPixel
except ImportError:
try: # Casio USB Power Graphic 3
import casioplot as myscr
self.show_screen = myscr.show_screen
self.need_show_screen = True
except ImportError: # NumWorks
import kandinsky as myscr
self.get_pixel = myscr.get_pixel
self.set_pixel = myscr.set_pixel
self.myscr = myscr
# detect readable pixel array
if self.w <= 0:
def _can_get_pixel(x, y):
c = self.get_pixel(x, y)
if c == self.color(0, 0, 0):
self.set_pixel(x, y, self.color(255,0,0))
c = self.get_pixel(x, y)
return c is not None and c != self.color(0, 0, 0)
self.w, self.h, dw, dh = 0, 0, 1, 1
while dw or dh:
if not _can_get_pixel(self.w - (dw == 0),self.h - (dh == 0)):
if _can_get_pixel(self.w,self.h-1): dh = 0
elif _can_get_pixel(self.w-1,self.h): dw = 0
else: dw, dh = 0, 0
self.w += dw; self.h += dh
# detect writable pixel array
# remove top status bar
def _can_set_pixel(x, y):
def _invert_color(r, g=0, b=0):
if isinstance(r, tuple) or isinstance(r,list):
r, g, b = r[0], r[1], r[2]
return self.color(~r & 0xFF, ~g & 0xFF, ~b & 0xFF)
c = self.get_pixel(x, y)
self.set_pixel(x, y, _invert_color(c))
return c != self.get_pixel(x, y)
self.w0, self.h0 = self.w, self.h
while not _can_set_pixel(0, self.y0):
self.y0 += 1; self.h0 -= 1from polyscr import *
scr = polyscr()
def grad(x,y,w,h):
for i in range(w):
for j in range(h):
c=scr.myscr.hsv_to_rgb(360*j/(h-1),i>=w//2 and 1 or i/(w//2-1),i<w//2 and 1 or (w-1-i)/((w-w//2)-1))
scr.set_pixel(x+i,y+j,c)
Ce n'est pas la révolution mais c'est quand même significatif, l'appel timer(grad, scr.x0, scr.y0, scr.w0, scr.h0) ne mesure plus que Bon, revenons-en enfin à cet affichage de dégradé. Si tu regardes bien, tu remarqueras que les lignes tirant sur le vert donnent 2 fois plus de teintes intermédiaires et donc un dégradé bien plus continu, bien moins saccadé.import prime as scr
def grad(x,y,w,h):
for i in range(w):
for j in range(h):
_h = 2*j/(h-1)
_s = i>=w//2 and 1 or i/(w//2-1)
_v = i<w//2 and 1 or (w-1-i)/((w-w//2)-1)
_c=_v*_s
_x,_m,_k=_c*(1-abs((_h%(2/3))*3-1)),_v-_c,(_h*3)//1
scr.pixon(x+i,y+j,round(255*(_m+_x*(_k%3==1)+_c*(_k%5==0)))*2**16 + round(255*(_m+_c*(_k==1 or _k==2)+_x*(_k%3==0)))*2**8 + round(255*(_m+_x*(_k%3==2)+_c*(_k==3 or _k==4))))
Ici encore, il serait bien de pouvoir détecter cela automatiquement sans intervention humaine.class polyscr:
w, h, w0, h0, x0, y0 = 0, 0, 0, 0, 0, 0
col_bits = [8, 8, 8]
myscr = None
# get_pixel(x, y)
# set_pixel(x, y, color(r8, g8, b8))
show_screen = lambda self: None
need_show_screen = False
# color mode :
# 0: (R8, G8, B8)
# 1: int RGB-565
color_mode = 0
has_color = True
def color(self, r, g=0, b=0):
if isinstance(r, tuple) or isinstance(r,list):
r, g, b = r[0], r[1], r[2]
return self.color_mode == 0 and (r,g,b) or r<<(self.col_bits[0]+self.col_bits[1]) | g<<self.col_bits[0] | b
def __init__(self):
try: # TI-Nspire Ndless
from nsp import Texture as myscr
self.w, self.h = 320, 240
myscr = myscr(self.w, self.h, None)
self.get_pixel = myscr.getPx
self.set_pixel = myscr.setPx
self.show_screen = myscr.display
self.need_show_screen = True
self.color_mode = 1
self.col_bits = (5, 6, 5)
except:
try: # TI-83/84 CE
import ti_graphics as myscr
self.get_pixel = myscr.getPixel
self.set_pixel = myscr.setPixel
except ImportError:
try: # Casio USB Power Graphic 3
import casioplot as myscr
self.show_screen = myscr.show_screen
self.need_show_screen = True
except ImportError: # NumWorks
import kandinsky as myscr
self.get_pixel = myscr.get_pixel
self.set_pixel = myscr.set_pixel
self.myscr = myscr
# detect readable pixel array
if self.w <= 0:
def _can_get_pixel(x, y):
c = self.get_pixel(x, y)
if c == self.color(0, 0, 0):
self.set_pixel(x, y, self.color(255,0,0))
c = self.get_pixel(x, y)
return c is not None and c != self.color(0, 0, 0)
self.w, self.h, dw, dh = 0, 0, 1, 1
while dw or dh:
if not _can_get_pixel(self.w - (dw == 0),self.h - (dh == 0)):
if _can_get_pixel(self.w,self.h-1): dh = 0
elif _can_get_pixel(self.w-1,self.h): dw = 0
else: dw, dh = 0, 0
self.w += dw; self.h += dh
# detect writable pixel array
# remove top status bar
def _can_set_pixel(x, y):
def _invert_color(r, g=0, b=0):
if isinstance(r, tuple) or isinstance(r,list):
r, g, b = r[0], r[1], r[2]
return self.color(~r & 0xFF, ~g & 0xFF, ~b & 0xFF)
c = self.get_pixel(x, y)
self.set_pixel(x, y, _invert_color(c))
return c != self.get_pixel(x, y)
self.w0, self.h0 = self.w, self.h
while not _can_set_pixel(0, self.y0):
self.y0 += 1; self.h0 -= 1
if not self.color_mode:
# test color screen
self.set_pixel(self.x0, self.y0, (0, 127, 255))
col = self.get_pixel(self.x0, self.y0)
self.has_color = col[0] != col[1] or col[1] != col[2]
# detect color channel bits
self.set_pixel(self.x0, self.y0, (255, 255, 255))
col = list(self.get_pixel(self.x0, self.y0))
for k in range(3):
while col[k]<255:
col[k] += 2 ** (8 - self.col_bits[k])
self.col_bits[k] -= 1
Appelons enfin le code suivant pour obtenir l'intégralité des informations écran, et les comparer aux solutions concurrentes :scr = polyscr()
print('can get {}x{} pixels at (0,0)'.format(scr.w, scr.h))
print('can set {}x{} pixels at ({},{})'.format(scr.w0, scr.h0, scr.x0, scr.y0))
print(scr.has_color and 'color' or 'monochrome')
if scr.has_color: print('internal : RGB{}{}{}'.format(scr.col_bits[0], scr.col_bits[1], scr.col_bits[2]))
from time import monotonic
def timer(f, *par):
start=monotonic()
f(*par)
return monotonic()-startfrom ti_graphics import *
def rectf(x, y, w, h, c=(0, 0, 0)):
for i in range(h):
for k in range(w):
setPixel(x+j, y+i, c)
L'appel timer(rectf, 0, 30, 320, 210, (255, 0, 0))) nous retourne from kandinsky import *
def rectf(x, y, w, h, c=(0, 0, 0)):
for i in range(h):
for k in range(w):
set_pixel(x+j, y+i, c)timer(rectf, 0, 30, 320, 222, (255, 0, 0))) pour chronométrer l'allumage de from casioplot import *
def rectf(x, y, w, h, c=(0, 0, 0)):
for i in range(h):
for k in range(w):
set_pixel(x+j, y+i, c)
show_screen()rectf(0, 0, 128, 64, (0, 0, 0) sur rectf(0, 0, 384, 192, (255, 0, 0) sur import nsp.Texture as scr
scr = scr(320, 240, None)
def rectf(x, y, w, h, c=0):
for i in range(h):
for k in range(w):
scr.setPx(x+j, y+i, c)
scr.display()rectf(0, 0, 320, 240, 31) sur rectf(0, 0, 320, 240, 31) sur rectf(0, 0, 320, 240, 0) sur from prime import *
def rectf(x, y, w, h, c=0):
for i in range(h):
for k in range(w):
pixon(x+j, y+i, c)
drawString('texte', x, y).
Mais ici rien à voir avec les précédentes, from ti_system import *
import ti_graphics as scr
tw = 10
s = 'Thank you TI'
xmin, xmax, ymin, ymax = 0, 319, 30, 239
x, y, dx, dy = xmin, ymin, 1, 9
scr.cls()
while x <= xmax - tw*len(s):
scr.drawString(s, x, y)
y += dy
x += dx
dx += 1
disp_wait()Abordons maintenant les autres fonctions de tracer de 
La fonction cursor(c=1) permet d'activer ou désactiver l'affichage du curseur de texte, comme le permettait déjà la fonction ti_system.cursor(c).
Autre différence également; contrairement à setColor(r, g, b), appel équivalent à ti_plotlib.color(r, g, b).setPen(taille, type), un appel donc similaire à ti_plotlib.pen('taille', 'type').def setPen(taille, type):
_strtest(taille)
_strtest(type)
if taille == 'thin': taille = 0
elif taille == 'medium': taille = 1
elif taille == 'thick': taille = 2
else: _excpt('Invalid pen size.')
if type == 'solid': type = 0
elif type == 'dot': type = 1
elif type == 'dash': type = 2
else: _excpt('Invalid pen style.')
gr.pen(taille, type)drawLine(x1, y1, x2, y2) :from ti_system import *
import ti_graphics as scr
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, 319, 30+th, 239
nta, nty = 4, 4
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)
scr.cls()
for i in range(nty):
scr.drawString(str(i), xmin-tw, ly[i*2])
for j in range(nta):
scr.drawString(str(j), lx[j*2], ymin-th)
scr.setPen(j, i)
scr.drawLine(lx[j*2], ly[i*2], lx[j*2 + 1], ly[i*2])
disp_wait()
Ci-contre l'affichage obtenu, ainsi que pour comparaison celui du test similaire dans le contexte de la fonction setPen(0, 0) = ti_plotlib.pen('thin', 'solid')setPen(1, 1) = ti_plotlib.pen('medium', 'dot')setPen(2, 2) = ti_plotlib.pen('thick', 'dash')setPen(3, 3), il permet donc d'accéder à deux réglages secrets non offerts via drawPolyLine([(x1,y1), (x2,y2), ..., (xn,yn)]) et fillPolyLine([(x1,y1), (x2,y2), ..., (xn,yn)]) :from ti_system import *
import ti_graphics as scr
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, 319, 30+th, 239
nta, nty = 4, 4
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)
scr.cls()
for i in range(nty):
scr.drawString(str(i), xmin-tw, ly[i*2])
for j in range(nta):
scr.drawString(str(j), lx[j*2], ymin-th)
scr.setPen(j, i)
scr.setColor((255,0,0))
scr.fillPolygon([(lx[j*2], ly[i*2]), (lx[j*2 + 1], ly[i*2]), (lx[j*2], ly[i*2+1]), (lx[j*2 + 1], ly[i*2+1])])
scr.setColor((0,0,0))
scr.drawPolyLine([(lx[j*2], ly[i*2]), (lx[j*2 + 1], ly[i*2]), (lx[j*2], ly[i*2+1]), (lx[j*2 + 1], ly[i*2+1])])
disp_wait()
La fonction def drawPolyLine(l):
for k in range(len(l) - 1):
drawLine(l[k][0], l[k][1], l[k+1][0], l[k+1][1])drawRect(x, y, w, h) et fillRect(x, y, w, h) :from ti_system import *
import ti_graphics as scr
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, 319, 30+th, 239
nta, nty = 4, 4
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)
scr.cls()
for i in range(nty):
scr.drawString(str(i), xmin-tw, ly[i*2])
for j in range(nta):
scr.drawString(str(j), lx[j*2], ymin-th)
scr.setPen(j, i)
scr.setColor((255,0,0))
scr.fillRect(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2])
scr.setColor((0,0,0))
scr.drawRect(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2])
disp_wait()
drawRect(x, y, w, h) permet donc de tracer un rectangle :drawArc(x, y, w, h, t1, t2) et fillArc(x, y, w, h, t1, t2) :from ti_system import *
import ti_graphics as scr
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, 319, 30+th, 239
nta, nty = 4, 4
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)
scr.cls()
for i in range(nty):
scr.drawString(str(i), xmin-tw, ly[i*2])
for j in range(nta):
scr.drawString(str(j), lx[j*2], ymin-th)
scr.setPen(j, i)
scr.setColor((255,0,0))
scr.fillArc(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2], 0, 3150)
scr.setColor((0,0,0))
scr.drawArc(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2], 0, 3150)
disp_wait()
La fonction drawArc(x, y, dx, dy, t1, t2) permet donc de tracer un arc d'une ellipse elle-même inscrite dans un rectangle :
Petite curiosité, nous avons une fonction fillCircle(x, y, r) permettant de préciser des éléments caractéristiques différents plus naturels dans le cas particulier d'un disque. La fonction serait donc équivalente au code suivant :def fillCircle(x, y, r):
fillArc(x-r, y-r, 2*r, 2*r, 0, 3600)drawCircle(x, y, r) pour le tracé d'un cercle, obligeant dans ce cas à utiliser une logique complètement différente.from ti_system import *
import ti_graphics as scr
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, 319, 30+th, 239
nta, nty = 4, 4
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)
scr.cls()
for i in range(nty):
scr.drawString(str(i), xmin-tw, ly[i*2])
for j in range(nta):
scr.drawString(str(j), lx[j*2], ymin-th)
scr.setPen(j, i)
scr.setColor((255,0,0))
scr.fillCircle(lx[j*2]+(ly[i*2+1]-ly[i*2])/2, (ly[i*2]+ly[i*2+1])/2, (ly[i*2+1]-ly[i*2])/2)
scr.setColor((0,0,0))
scr.drawArc(lx[j*2], ly[i*2], ly[i*2+1]-ly[i*2], ly[i*2+1]-ly[i*2], 0, 3600)
disp_wait()
L'appel pushImage(x, y, w, h) semble définir une image de dimensions from ti_system import *
import ti_graphics as scr
scr.pushImage(50, 50, 269, 170)
scr.popImage()
disp_wait()drawImage(?, ?, ?) doit pour sa part servir à dessiner l'image en question avant affichage, mais nous n'avons pas réussi à en comprendre le fonctionnement.scr.drawImage('Image1', 50, 50) semble ne rien donner.
La fonction privée _write('') semble être équivalente avec ti_plotlib._write('')._read(n). Attention, si on lui demande de lire plus de données qu'il y en a, on ne sait où en passant, la calculatrice rentre dans une boucle d'attente infinie qu'il est apparemment impossible d'interrompre autrement que par un _grcmd(''), _grcif('') et _handshake(?).by critor » 05 May 2020, 11:19
Cette dernière application apporte de nouveaux modules importables pour tes scripts 2ndeou
alpha)
