La rappresentazione grafica del Pascal

Materie:	Appunti
Categoria:	Matematica
Voto:	1 (2)
Download:	152
Data:	13.11.2001
Numero di pagine:	6
Formato di file:	.doc (Microsoft Word)

3I. LA RAPPRESENTAZIONE GRAFICA IN PASCAL

§1. I limiti grafici del modo Testo
Lo schermo di Testo di default è formato da un rettangolo di 25 righe x 80 colonne. L'uso della clausola uses Crt; permette di governare lo schermo di Testo con le seguenti procedure:
ClrScr; {Pulisce lo schermo}
Delay(X: word); {Ritarda di X msec}
GotoXY(C, R: byte); {Porta il cursore a colonna C e a riga R}
HighVideo; {Seleziona caratteri ad alta luminosità}
LowVideo; {Seleziona caratteri a bassa luminosità}
NormVideo; {Ripristina la luminosità di default dei caratteri}
KeyPressed; {Restituisce il valore True a pressione d'un tasto}
Sound(H: word); {Genera un suono di H hertz}
NoSound; {Disattiva l'altoparlante interno}
ReadKey; {Legge il carattere premuto senza visualizzarlo}
TextColor(C: byte); {Seleziona il colore del carattere secondo il seguente codice: C:=0 NERO, 1 BLU, 2 VERDE, 3 CIANO, 4 ROSSO, 5 MAGENTA, 6 MARRONE, 7 GRIGIO CHIARO, 8 GRIGIO SCURO, 9 AZZURRO, 10 VERDE CHIARO, 11 CIANO CHIARO, 12 ROSSO CHIARO, 13 MAGENTA CHIARO, 14 GIALLO, 15 BIANCO. Sommando a C +128 si ottiene l'effetto lampeggiante}
TextBackGround(C: byte); {Seleziona il colore di sfondo, in base allo stesso codice di TextColor, ma limitato ai valori da 0 a 7}
Window(X1, Y1, X2, Y2: byte); {Definisce una finestra di testo. Window(1, 1, 80, 25) ripristina le dimensioni dello schermo}
I seguenti programmi esemplificano la "musica" e la "grafica" possibili:
program Sonata;
uses Crt;
const
DO_ = 523; {Il trattino è necessario perché Do è una parola riservata}
RE_ = 587;
MI_ = 659;
FA_ = 699;
SOL = 784;
LA_ = 880;
SI_ = 988;
var
Tasto: char;
FuoriScala: boolean;
Nota: word;
begin
ClrScr;
FuoriScala:= False;
Repeat
Tasto:= ReadKey;
Case Tasto of
'1': Nota:= DO_;
'2': Nota:= RE_;
'3': Nota:= MI_;
'4': Nota:= FA_;
'5': Nota:= SOL;
'6': Nota:= LA_;
'7': Nota:= SI_
Else FuoriScala:= True
end;
If not FuoriScala Then begin
Write(Tasto:2); {Visualizza ogni nota}
Sound(Nota);
Delay(100); {100 msec = 0.1 sec}
NoSound
end
Until FuoriScala;
WriteLn
end.
program Finestre;
uses Crt;
var
Riga, Colonna: byte;
begin
ClrScr;
For Colonna:= 1 to 80 do
For Riga:= 1 to 23 do begin
GotoXY(Colonna, Riga);
TextColor(Random(6) + 1);
Write('*')
end;
Window(25, 8, 55, 16);
ClrScr;
GotoXY(13, 5);
TextColor(Red + Blink);
Write('BRAVO!');
ReadLn;
Window(1, 1, 80, 25)
end.
Nient'altro, o quasi. Per fare della vera musica o della vera grafica ci vuole ben altro. Ora, se per la musica occorre senz'altro rivolgersi a software appositi ed anche implementare nuovo hardware, per la grafica invece TurboPascal fornisce un modulo (GRAPH) di routine, che innescato dalla clausola uses Graph; può dar luogo a pregiati disegni, specie di carattere geometrico. Naturalmente, per chi si volesse dedicare al design artistico, pubblicitario, cinematografico, o all'animazione, è più opportuno avvalersi d'un apposito software applicativo, come CorelDraw.
§2. Il modo Grafico
Se osserviamo da vicino un qualsiasi carattere nel modo Testo, ci accorgiamo che esso è costituito di piccoli punti luminosi detti pixel (acronimo di picture element). Nel modo Testo, lo schermo viene diviso in 80x25=2000 blocchetti rettangolari, ognuno composto di 9x14=126 pixel. Ogni blocchetto può contenere uno dei 256 caratteri ASCII ed è controllato dalla scheda video dell'hardware. In modo Grafico, invece, ogni singolo pixel può essere controllato dalla scheda grafica come
- posizione: acceso o spento;
- colore;
- luminosità.
Naturalmente è necessario utilizzare un apposito software per adattare le istruzioni del programma in Pascal alla specifica scheda grafica di ogni monitor. Per questo, la Borland fornisce un'interfaccia grafica (BGI, o Borland Graphics Interface), che è contenuta nei file ad estensione *.BGI; questi file si chiamano driver, o pilota, proprio perché tecnicamente guidano il mappaggio dei pixel, ossia convertono gli specifici comandi TurboPascal in istruzioni che possono essere comprese dalla scheda grafica.
La risoluzione dello schermo è determinata dal numero di pixel che contiene. Maggiore è il loro numero, maggiori sono la vividezza e la nitidezza delle immagini. Le fotografie dei giornali sono notoriamente "povere" rispetto alle immagini fotografiche; a metà strada si trova la risoluzione della televisione attuale. Oggi, i monitor dei computer sono quasi tutti ad alta definizione, con scheda VGA Hi, ossia (almeno) 640x480 = 307200 pixel e (almeno) 16 colori.
La posizione di ogni pixel è definita da una coppia di coordinate cartesiane (X,Y), che vanno dalla coppia (0,0) per l'angolo in alto a sinistra, alla coppia (639,479) per l'angolo in basso a destra nell'adattatore VGA. Il centro dello schermo è quindi il pixel (320,240).
§3. L'inizializzazione del modo Grafico
Il modo di default in Pascal è quello Testo, essendo questo più comunemente usato. Per entrare in modo Grafico occorre richiamare la procedura
InitGraph(Driver, Modo, Path);
dove Driver identifica il codice del driver (cioè del programma pilota di estensione .BGI), Modo è il codice del modo grafico ottimale in cui quel driver può guidare il particolare adattatore grafico e Path racchiude tra apici il cammino della sottodirectory contenente i driver grafici. Path è il più facile da determinare, e di solito è
'C:\TP' oppure
'C:\TP\BGI'.
Basta in ogni caso controllare, per es. in DOS col comando dir c:\tp, dove sono collocati i file *.BGI.
Driver e Modo hanno dei codici integer, che variano a seconda della scheda grafica. Essi si possono trovare nei manuali. TurboPascal è tuttavia dotato di una routine (DetectGraph) per riconoscere i codici dell'adattatore in nostro possesso: basta usare il programma
program GrafInfo;
uses Graph;
var Driver, Modo: integer;
begin
DetectGraph(Driver, Modo);
WriteLn('Codice driver = ', Driver);
WriteLn('Codice modo = ', Modo);
ReadLn
end.
DetectGraph è una funzione a 2 uscite che controlla l'hardware installato e determina quale driver e quale modo usare. I parametri che essa restituisce vanno dall'utente memorizzati ed usati ogniqualvolta si debba scrivere un programma grafico. Noi tuttavia, per pigrizia o perché usiamo ogni giorno computer diversi, utilizzeremo un altro metodo ancora per inizializzare la grafica, senza bisogno di memorizzare i parametri della scheda: struttureremo inizialmente i programmi così
program X;
uses Graph;
var Driver, Modo: integer;
.....................;
begin
Driver:= Detect;
InitGraph(Driver, Modo, 'C:\TP'); {o 'C:\TP\BGI'}
.......................;
.......................;
ReadLn;
CloseGraph
end.
Con la function Detect i parametri Driver e Modo sono, di volta in volta, automaticamente ricercati ed ottimizzati da TurboPascal. CloseGraph è una procedura che, all'inverso, disattiva il sistema grafico, e libera il buffer dal programma pilota e da ogni routine grafica utilizzata. Se lo schermo era in modo Testo prima della chiamata di InitGraph, dopo CloseGraph ritornerà in modo Testo. Senza la chiamata di CloseGraph, il programma terminerebbe regolarmente, ma lo schermo rimarrebbe in modo grafico: dovremmo allora ripristinare il modo Testo da noi, o con complicati comandi Dos o facendo ripartire il PC.

§4. Primi comandi grafici
Per chi usa diversi computer, TurboPascal ha due function che restituiscono le coordinate cartesiane massime dei pixel, cioè 639 e 479 per i VGA: GetMaxX e GetMaxY; il centro dello schermo è così, per es., automaticamente determinabile dalle istruzioni
X:= GetMaxX div 2;
Y:= GetMaxY div 2;
Il seguente programma fornisce un utilizzo di queste function:
program Palloncino;
uses Graph;
var
Pilota, Modo: integer;
XO, YO, Raggio: word;
begin
Driver:= Detect;
InitGraph(Pilota, Modo, 'C:\TP\BGI');
XO:= GetMaxX div 2;
YO:= GetMaxY div 2;
Raggio:= GetMaxY div 4;
Circle(XO, YO, Raggio);
ReadLn;
CloseGraph
end.
La routine Circle(X, Y, R) traccia il cerchio di centro (X,Y) e raggio R. Per tracciare il segmento di retta che congiunge il punto (X1,Y1) col punto (X2,Y2), la routine è invece Line(X1, Y1, X2, Y2). Un'applicazione si ha nel seguente programma che, tracciando una famiglia intera di rette, fa apparire di risulta una curva (detta in Matematica "inviluppo" della famiglia di rette) avente le rette come tangenti in ogni suo punto:
program Inviluppo;
uses Graph;
var
Driver, Modo,
y, YMed: integer;
begin
Driver:= Detect;
InitGraph(Driver, Modo, 'c:\tp\bgi');
YMed:= GetMaxY div 2;
For y:= 1 to YMed do begin
Line(YMed - y, 0, 0, y);
Line(YMed + y, 0, GetMaxY, y);
Line(0, YMed + y, y, GetMaxY);
Line(YMed + y, GetMaxY, GetMaxY, GetMaxY - y)
end;
ReadLn;
CloseGraph
end.
L'uso nel ciclo For... to... do d'un rallentatore, per es. Delay(100), naturalmente con l'innesco della clausola Crt, può enfatizzare l'effetto di produzione dell'inviluppo.
Se vogliamo invece tracciare singoli punti, di questo o quel colore, utilizzeremo il comando PutPixel(X, Y, C). Esso, usato con X,Y,C numeri naturali, accende il pixel di coordinate (X,Y) e di colore C (i codici dei colori sono gli stessi di TextColor). Dunque 0