# La Geometria interattiva (superiori)
## Introduzione

Cos'è la geometria interattiva, i primi oggetti.
La geometria interattiva permette di creare gli oggetti della geometria euclidea:
* Punti.
* Rette.
* Circonferenze.
I punti possono essere:
* Liberi.
* Vincolati a una linea.
* Intersezioni di due linee.
Le rette possono essere anche:
* Semirette.
* Segmenti.
I punti base possono essere trascinati con il mouse quindi, se ho realizzato una costruzione geometrica a partire da alcuni punti, quando muovo questi punti tutta la costruzione si muove. La Geometria interattiva mette in evidenza quali sono le caratteristiche invarianti e quali quelle variabili di una certa costruzione. Esistono molti programmi che permettono di operare con la geometria interattiva, a questo indirizzo se ne possono trovare ben 36: http://en.wikipedia.org/wiki/List_of_interactive_geometry_software In questo testo propongo l'uso del linguaggio Python con la libreria pyig. È comunque possibile seguire il percorso proposto anche con un programma punta e clicca invece che con un linguaggio. Per l'installazione di Python e della libreria Pygraph, che contiene anche Pyig, vedi l'introduzione alla geometria della tartaruga nel volume precedente.

### Installiamo un interprete

Cosa installare per lavorare con la geometria interattiva.
Python
Chi usa come sistema operativo Windows può installare Python a partire dal sito: www.python.org/downloads E installare la versione più recente della serie 3.x.x. Chi utilizza altri sistemi operativi può installarlo partendo dal proprio gestore di pacchetti installando Python3 e anche IDLE.
pygraph
Si può scaricare l'intero pacchetto da: bitbucket.org/zambu/pygraph/downloads A questo punto bisogna fare a mano alcune operazioni che dipendono dal proprio sistema operativo:
Windows
* Scompattare il file scaricato.
* Entrare nella cartella pygraph.
* Selezionare il file pygraph.pth e la cartella pygraph lì presenti.
* Copiarli nella cartella C:\Python3x\Lib\site-package
Dove “Python3x” potrebbe essere: “Python34”, “Python35” ...
MacOSX
* Scompattare il file scaricato.
* Entrare nella cartella pygraph.
* Selezionare il file pygraph.pth e la cartella pygraph lì presenti.
* Copiarli nella cartella HD/libreria/python/3.x/site-package
Se in “HD/libreria/python/” non è presente la cartella “3.4/site-packages”, bisogna crearla.
GNU/Linux
* Scompattare il file scaricato.
* Entrare nella directory pygraph.
* Aprire un terminale in questa directory.
* Copiare la cartella pygraph e il file pygraph.pth nella cartella /usr/lib/python3/dist-packages/
Dato che in Linux, per modificare le directory di sistema bisogna essere amministratori, il comando da dare assomiglierà a questo:
sudo cp -R python* /usr/lib/python3/dist-packages/
A questo punto se tutto è andato bene dovremmo essere in grado di avviare Python-IDLE e dare il comando: import pyig as ig Se non succede nulla vuol dire che tutto è andato a buon fine, se invece appare una scritta rossa, bisogna leggere almeno l'ultima riga e cercare di capire cosa non è andato bene. Magari ci si può far aiutare da qualcuno esperto nell'installazione di programmi. Se tutto è andato per il verso giusto possiamo procedere.
Riassumendo
* La geometria interattiva permette di creare e di muovere gli oggetti della geometria euclidea.
* Ci sono molti programmi che permettono di giocare con la geometria interattiva, noi utilizzeremo il linguaggio Python con la libreria pyig.
* Gli oggetti di base sono:
** Punti:
*** Liberi.
*** Vincolati.
*** Intersezioni.
** Rette:
*** Rette.
*** Semirette.
*** Segmenti.
** Circonferenze.

## Elementi fondamentali

Come creare un piano vuoto, dei punti, delle rette e altri oggetti geometrici.
La geometria interattiva permette di visualizzare facilmente elementi varianti e invarianti di una certa costruzione geometrica.

### Strumenti

In questo capitolo utilizzeremo i seguenti strumenti di Pyig:
* Point(x, y) crea un punto con date coordinate.
* Line(p0, p1) crea una retta passante per p0 e p1.
* Ray(p0, p1) crea una semiretta con origine in p0 passante per p1.
* Segment(p0, p1) crea un segmento di estremi p0 e p1.
* Circle(centro, punto) crea una circonferenza dati il centro e un suo punto.

### Problema

Crea un piano e disegna i quattro vertici di un quadrato, poi disegna i quattro lati del quadrato. Modifica poi la figura trascinando i punti base con il mouse.

### Soluzione guidata

1. Crea un nuovo programma e salvarlo con il nome: gi01_elementi.py. Per creare un nuovo programma:
* Avvia IDLE (in Windows: menu-programmi-Python-IDLE).
* crea un nuovo editor: menu-file-new window.
* salvalo nella tua cartella con il nome desiderato: menu-file-save.
2. Incomincia a scrivere il programma.
* Scrivi un'intestazione fatta da commenti che contenga le informazioni:
* Data.
* Nome.
* Titolo del programma.
Esegui il programma in modo da controllare che non ci siano errori (<F5>).
3. Il programma vero e proprio è fatto da tre parti:
* La lettura delle librerie.
* Il programma principale.
* L'attivazione della finestra grafica.
A questo punto il programma assomiglierà a:
# <data>
# <autore>
# Elementi di base della geometria
""" Problema: Disegna i quattro vertici di un quadrato. Disegna i quattro lati del quadrato. """
# lettura delle librerie
# programma principale
# attivazione della finestra grafica
4. Fin qui abbiamo scritto solo commenti, ora incominciamo a scrivere comandi:
* Leggo la libreria Pyig e le do un nome più breve, “ig”:
import pyig
* Il programma principale consiste, per ora, in una sola istruzione, creo un “InteractivePlane” della libreria “ig” e associo questo oggetto all'identificatore (=alla parola) “ip”:
ip = pyig.InteractivePlane
* Rendo attiva la finestra grafica:
ip.mainloop
5. Aggiungi le istruzioni sotto ai commenti:
# <data>
# <autore>
# Elementi di base della geometria
""" Problema: Disegna i quattro vertici di un quadrato. Disegna i quattro lati del quadrato. """
# lettura delle librerie import pyig as ig
# programma principale ip = ig.InteractivePlane
# attivazione della finestra grafica ip.mainloop
6. Prova il programma premendo il tasto: <Ctrl-F5> o cliccando su menu-Run-Run module. Deve apparire una finestra grafica con un riferimento cartesiano e una griglia di punti. La finestra grafica è attiva, risponde al mouse e si può chiudere. Se non avviene questo, probabilmente è apparso un messaggio di errore in rosso nella shell di IDLE, leggi il messaggio, correggi l'errore e ritenta. Ora incominciamo ad aggiungere al programma principale le istruzioni per risolvere il problema. Incominciamo creando un punto. Aggiungiamo al programma principale il comando della libreria pyig che crea un punto associando l'oggetto appena creato all'identificatore “p_0”: p_0 = ig.Point(3, 4) È possibile trascinare con il mouse il punto nel suo piano: il punto non cambia cambiando la sua posizione. In geometria un punto non dovrebbe avere altre caratteristiche oltre la propria posizione, ma a noi fa comodo poter dare ai punti anche altre caratteristiche come: uno spessore, un colore, un'etichetta: p_0 = ig.Point(3, 4, color = 'red', width=6, name= 'A') In generale a tutti gli oggetti di pyig che possono essere visualizzati si possono assegnare le seguenti caratteristiche:
* Colore: color=<una stringa di colore>.
* Spessore: width=<un numero>.
* Etichetta: name=<una stringa>.
* Visibilità: visible=<True> o <False>.
La sintassi del costruttore dell'oggetto Point è: Point (<x> , <y> [, visible =True][, color ='green'][, width =3][, name='']) I primi due parametri, x e y, sono obbligatori, quelli messi tra parentesi quadre sono opzionali e, se non specificati, hanno il valore riportato sopra. Passiamo alla seconda richiesta del problema: disegnare una retta.Per poter tracciare una retta abbiamo bisogno di due punti infatti due punti individuano univocamente una retta (per due punti passa una e una sola retta). Possiamo utilizzare i due punti già disegnati e creare la retta passante per p_0 e p_1: s_0 = ig.Segment(p_0, p_1) Anche in questo caso possiamo modificare “colore” e “spessore” del segmento: s_0 = ig.Segment(p_0, p_1, color ='pink', width=6) # lati La sintassi del costruttore dell'oggetto Segment è: Segment(<punto_0>, <punto_1> [, visible =True][, color = 'blue'][, width =3][, name='']) È possibile trascinare con il mouse i punti base del segmento, ma il segmento continuerà a passare per quei due punti. Le sintassi dei costruttori di alcuni altri oggetti della geometria interattiva: Line(<punto_0>, <punto_1> [, visible =True][, color = 'blue'][, width =3][, name='']) Ray(<punto_0>, <punto_1> [, visible =True][, color = 'blue'][, width =3][, name='']) Circle(<centro>, <uunto> [, visible =True][, color = 'blue'][, width =3][, name='']) Ora crea tu una retta, una semiretta e una circonferenza.
Riassumendo
* Per lavorare con la geometria interattiva dobbiamo far caricare a Python la relativa libreria ad esempio con il comando:
import pyig
* Un programma è composto (per ora) dalle seguenti parti:
<intestazione>
<lettura delle librerie>
<programma principale>
<attivazione della finestra grafica>
* La sintassi dei costruttori degli oggetti base della geometria è:
Point(<x> , <y> [, visible =True][, color ='green'][, width =3][, name='']) Line(<punto_0>, <punto_1> [, visible =True][, color = 'blue'][, width =3][, name='']) Ray(<punto_0>, <punto_1> [, visible =True][, color = 'blue'][, width =3][, name='']) Segment(<punto_0>, <punto_1> [, visible =True][, color = 'blue'][, width =3][, name='']) Circle(<centro>, <punto> [, visible =True][, color = 'blue'][, width =3][, name=''])

## Intersezioni

Come usare intersezioni tra oggetti.
Oltre a quelli visti nel capitolo precedente, per poter realizzare costruzioni geometriche abbiamo bisogno di poter creare l'intersezione tra due rette, tra una retta e una circondìferenza o tra due circonferenze.

### Strumenti

In questo capitolo utilizzeremo i seguenti strumenti di Pyig:
* Point(x, y) crea un punto con date coordinate.
* Line(p0, p1) crea una retta passante per p0 e p1.
* Segment(p0, p1) crea un segmento di estremi p0 e p1.
* Intersection(oggetto_0, oggetto_1, [which]) crea un punto di intersezione tra due oggetti.

### Problema

Crea un piano e inserisci:
* Due rette nel terzo e quarto quadrante e il segmento che congiunge la loro intersezione con l'origine.
* Una retta e una circonferenza nel secondo quadrante e i segmenti che congiungono le loro intersezioni con l'origine.
* Due circonferenze nel primo quadrante e i segmenti che congiungono le loro intersezione con l'origine.

### Soluzione guidata

1. Crea un nuovo programma e salvarlo con il nome: gi02_intersezioni.py. Per creare un nuovo programma: vedi la soluzione guidata del capitolo precedente.
2. Scrivi un'intestazione adeguata.
3. Scrivi lo scheletro del programma:
* La lettura delle librerie.
* Il programma principale.
* L'attivazione della finestra grafica.
e verifica che tutto funzioni.
4. Ora scriviamo dei commenti che indicano come intendiamo risolvere il problema:
# Creo le due rette
# Creo un punto nell'origine degli assi
# Creo l'intersezione tra le due rette
# Creo il segmento che congiunge l'origine all'intersezione
5. A questo punto il programma dovrebbe apparire circa così:
# <data>
# <nome>
# Intersezioni
# lettura delle librerie
import pyig as ig
# programma principale
ip = ig.InteractivePlane
# Creo le due rette
# Creo un punto nell'origine degli assi
# Creo l'intersezione tra le due rette
# Creo il segmento che congiunge l'origine all'intersezione
# attivazione della finestra grafica
ip.mainloop
6. Ora iniziamo a popolare di istruzioni il programma principale creando le due rette:
r_0 = ig.Line(ig.Point(-6, -4, width =6), ig.Point(2, -6, width =6))
r_1 = ig.Line(ig.Point(-11 , -9, width =6), ig.Point(-3, -8, width =6))
Eseguiamo il programma controllando che rispetti le specifiche.
7. Ora dobbiamo creare un segmento con un estremo nell'origine, quindi dobbiamo creare un punto nell'origine:
origine = ig.Point(0, 0, visible =False)
e siccome vogliamo che nessuno possa muoverlo, lo facciamo invisibile.
8. L'altro estremo è l'intersezione delle due rette:
i _ 0 = ig.Intersection(r_0, r_1, color ='red')
9. Infine creiamo il segmento:
s_0 = ig.Segment(origine, i_0, color ='#505010')
10. A questo punto il programma dovrebbe apparire circa così:
# <data>
# <nome>
# Intersezioni
# lettura delle librerie
import pyig as ig
# programma principale
ip = ig.InteractivePlane
# Creo le due rette
r_0 = ig.Line(ig.Point(-6, -4, width =6), ig.Point(2, -6, width =6))
r_1 = ig.Line(ig.Point(-11, -9, width =6), ig.Point(-3, -8, width =6))
# Creo un punto nell'origine degli assi
origine = ig.Point(0, 0, visible =False)
# Creo l'intersezione tra le due rette
i_0 = ig.Intersection(r_0, r_1, color ='red')
# Creo il segmento che congiunge l'origine all'intersezione
s_0 = ig.Segment(origine, i_0, color ='#505010')
# attivazione della finestra grafica
ip.mainloop
11. Proviamo il programma e controlliamo che rispetti le specifiche richieste dal problema. Cosa succede quando muovo i punti base di una retta?
12. Se tutto funziona regolarmente possiamo passare alla seconda parte del problema:
# Creo una retta
# Creo una circonferenza
# Creo le intersezioni tra la retta e la circonferenza
# Creo i segmenti
13. Per quanto riguarda i primi due punti non dovrebbero esserci problemi, per il terzo invece presenta una novità rispetto a quanto visto per l'intersezione di due rette, infatti una retta interseca una circonferenza in due punti (e non sempre) e noi dobbiamo indicare a Python quale delle due intersezioni vogliamo:
i_1 = ig.Intersection(r_2, c_0, -1, color ='red')
i_2 = ig.Intersection(r_2, c_0, +1, color ='red')
14. Dopo aver controllato che fin qui il programma funzioni, disegniamo i due segmenti. la seconda parte dovrebbe assomigliare a questa:
# Creo una retta
r_2 = ig.Line(ig.Point(-11, 9, width =6), ig.Point(-6, 1, width =6))
# Creo una circonferenza
c_0 = ig.Circle(ig.Point(-6, 7), ig.Point(-5, 2))
# Creo le intersezioni tra la retta e la circonferenza
i_1 = ig.Intersection(r_2, c_0, -1, color ='red')
i_2 = ig.Intersection(r_2, c_0, +1, color ='red')
# Creo i segmenti
s_1 = ig.Segment(origine, i_1, color ='#10a010')
s_2 = ig.Segment(origine, i_2, color ='#10a080')
15. Proviamo il programma e controlliamo che rispetti le specifiche richieste dal problema. Cosa succede quando muovo i punti base della retta?
16. Completiamo il programma per risolvere anche la terza parte del problema.
Riassumendo
* pyig mette a disposizione un oggetto intersezione. L'intersezione tra rette non ha bisogno di ulteriori informazioni, quella tra una retta e una circonferenza o tra due circonferenze richiede un ulteriore argomento: con -1 si indica un'intersezione, con +1 si indica l'altra.
La sintassi del costruttore di un'intersezione è:
Intersection(oggetto_0, oggetto_1[,which] [,visible =True][,color ='blue'][, width=3][, name=''])

## Costruzioni geometriche

Come usare intersezioni tra oggetti.
Lo strumento base della geometria greca era lo spago:
* Tenendo teso un pezzo di corda si poteva rappresentare un segmento allungabile a piacere.
* Tenendo fisso un estremo e facendo ruotare l'altro, si poteva rappresentare una circonferenza.
Con questo strumento hanno costruito la geometria euclidea e risolto innumerevoli problemi.

### Strumenti

In questo capitolo utilizzeremo i seguenti strumenti di Pyig:
* Point(x, y) crea un punto con date coordinate.
* Line(p0, p1) crea una retta passante per p0 e p1.
* Segment(p0, p1) crea un segmento di estremi p0 e p1.
* Intersection(oggetto_0, oggetto_1, [which]) crea un punto di intersezione tra due oggetti.
* Polygon((punto0, punto1, punto2, ...)) crea un poligono dati i vertici.

### Problema

Crea un piano e disegna:
* Nel primo quadrante: due punti e il triangolo equilatero costruito su quei due punti.
* Nel secondo quadrante: un segmento e l'asse di quel segmento.
* Nel terzo quadrante: un angolo e la bisettrice di quell'angolo.
* Nel quarto quadrante: due punti e il quadrato costruito su quei due punti.

### Soluzione guidata

1. Crea un nuovo programma e salvarlo con il nome: gi03_costruzioni.py. Per creare un nuovo programma: vedi la soluzione guidata del primo capitolo.
2. Scrivi un'intestazione adeguata.
3. Scrivi lo scheletro del programma.
4. Ora scriviamo dei commenti che indicano come intendiamo risolvere il problema:
# Disegno tre punti disposti accuratamente
# Disegno il poligono che passa per i tre punti
5. Risolviamo la prima parte del problema ottenendo un programma principale simile a questo:
# programma principale
ip = ig.InteractivePlane
# Disegno tre punti disposti accuratamente
p_0 = ig.Point(1, 2, width=6)
p_1 = ig.Point(11, 2, width=6)
p_2 = ig.Point(6, 10.66, width=6)
# Disegno il poligono che passa per i tre punti
triequi = ig.Polygon((p_0, p_1, p_2),
width=5, color ='green', intcolor ='gold')
Osservate che il costruttore di Poligon vuole un primo argomento formato da una sequenza di punti per cui i vertici del poligono devono essere racchiusi tra parentesi.
6. Proviamo il programma e controlliamo che rispetti le specifiche richieste dal problema. Cosa succede quando muovo i punti base? Accidenti, il triangolo è equilatero all'inizio, ma non lo è più quando sposto uno dei punti base. Dobbiamo affrontare il problema in un altro modo. Il terzo vertice va costruito partendo dai primi due:
# Disegno due punti in una posizione qualunque
# Disegno le due circonferenze che hanno centro in un punto e
# passano per l'altro
# Trovo un'intersezione delle due circonferenze.
# Disegno il poligono che ha per vertici i due punti e l'intersezione
7. Dovremmo ottenere un programma che assomiglia a questo:
# programma principale
ip = ig.InteractivePlane
# Disegno due punti in una posizione qualunque
p_0 = ig.Point(1, 2, width=6)
p_1 = ig.Point(11, 2, width=6)
# Disegno le due circonferenze che hanno centro in un punto e
# passano per l'altro
c_0 = ig.Circle(p_0, p_1, width=1)
c_1 = ig.Circle(p_1, p_0, width=1)
# Trovo un'intersezione delle due circonferenze
p_2 = ig.Intersection(c_0, c_1, +1, width=6)
# Disegno il poligono che ha per vertici i due punti e l'intersezione
triequi = ig.Polygon((p_0, p_1, p_2),
width=5, color ='green', intcolor ='gold')
Osservate che è buona norma tenere le linee di costruzione più sottili rispetto alle altre, o addirittura renderle invisibili visible=False. Si può osservare che questa volta i punti liberi sono solo due, il terzo vertice è vincolato alla posizione di questi due dalla nostra costruzione. Ora, se muoviamo i punti base il nostro triangolo cambia posizione e dimensioni, ma resta sempre un triangolo equilatero come era richiesto dal problema.
8. A questo punto cerca su un libro di disegno su internet come risolvere gli altri tre problemi. Risolvili con riga e compasso, poi con pyig. Di seguito riporto le tre tracce di soluzione.
9. Asse di un segmento:
# Disegno due punti
# Disegno il segmento
# Disegno le due circ. che hanno centro in un estremo e passano per l'altro
# Chiamo i_0 e i_1 le due intersezioni delle circonferenze
# L'asse e' la retta passante per i_0 e i_1
10. Bisettrice di un angolo:
# Disegno tre punti: p_0, vertice, p_1
# Disegno i due lati dell'angolo: r_0 e r_1
# Disegno una circ. che ha centro nel vertice e passa per p_0
# Chiamo i_1 l'intersezione della circonferenze con il lato r_1
# Disegno le circonferenze di centro p_0 e i_1 passanti per il vertice
# Chiamo i_2 l'intersezione delle due circonferenze
# La retta vertice -i_2 e' la bisettrice cercata
11. Quadrato dati due vertici consecutivi:
# Disegno due punti: p_0 , p_1
# c_0 e' la circ. che ha centro in p_0 e passa per p_1
# c_1 e' la circ. che ha centro in p_1 e passa per p_0
# i_0 e' l'intersezione di queste due circonferenze c_0 e c_1
# c_2 e' la circ. che ha centro in i _ 0 e passa per p_0
# i_1 e' l'intersezione delle circonferenze c_0 e c_2
# c_3 e' la circonferenza di centro i_1 passante per p_0
# i_2 e' l'intersezione delle circonferenze c_3 e c_2
# r_0 e' la retta passante per p_0 e i_2
# p_3 e' l'intersezione della retta r_0 con la circonferenza c_0
# c_4 e' la circonferenza di centro i_3 passante per p_0
# p_2 e' l'intersezione della circonferenza c_4 con la circonferenza c_1
# Il quadrato cercato e il poligono di vertici: (p_0, p_1, p_2, p_3)
Quando il programma e complicato, come in quest'ultimo caso è importante eseguire il programma ogni volta che si aggiunge un'istruzione in modo da individuare immediatamente eventuali errori sia sintattici sia logici.
12. Completiamo il programma per risolvere anche la terza parte del problema.
Riassumendo
* Polygon permette di disegnare un poligono data una sequenza di punti. La sintassi del costruttore di Polygon è:
Polygon(sequenza di punti[, intcolor=white] [, visible =True][, color ='blue'][, width=3][, name=''])
* Per affrontare problemi complicati: prima pianifica la soluzione descrivendola per mezzo di commenti, poi scrivi le istruzioni per risolvere il problema eseguendo il programma ad ogni modifica.
* Nei libri d disegno, o in internet, si possono trovare molte costruzioni geometriche che si possono realizzare con rette, circonferenze e intersezioni.

## Strumenti di uso comune

Quali altri oggetti abbiamo a disposizione.
Nel paragrafo precedente abbiamo visto come realizzare oggetti nuovi come assi, bisettrici, triangoli, quadrati, ... Ma se ho bisogno di vari assi per realizzare una costruzione complessa, non è comodo per ognuno di questi ripetere tutta la costruzione. Alcuni oggetti di uso comune sono già prefabbricati e vengono messi a disposizione dalla libreria pyig, basta chiamarli. Nei prossimi paragrafi riporto quelli di uso più comune, l'elenco completo si trova nel manuale di Pygraph che è stato scaricato assieme alle librerie.

### Lettura della libreria

Nel seguito si dà per sottinteso che all'inizio del programma sia stata caricata la libreria con l'istruzione:
import pyig as ig

### InteractivePlane

InteractivePlane Crea il piano interattivo nel fare questa operazione si possono decidere alcune caratteristiche.
Sintassi
<nome_variabile> = InteractivePlane([<parametri>])
Osservazioni
Il costruttore presenta molti parametri tutti con un valore predefinito. Nel momento in cui si crea un piano cartesiano si possono quindi decidere le sue caratteristiche. Vediamole in dettaglio:
* Titolo della finestra, valore predefinito: “Interactive geometry”.
* Dimensione, valori predefiniti: larghezza=600, altezza=600.
* Scala di rappresentazione, valori predefiniti: una unità = 20 pixel.
* Posizione dell'origine, valore predefinito: il centro della finestra.
* Rappresentazione degli assi cartesiani, valore predefinito: True.
* Rappresentazione di una griglia di punti, valore predefinito: True.
* Colore degli assi valore predefinito: ‘#808080' (grigio).
* Colore della griglia valore predefinito: ‘#808080'.
* Riferimento alla finestra che contiene il piano cartesiano, valore predefinito: None.
Poiché tutti i parametri hanno un valore predefinito, possiamo creare un oggetto della classe InteractivePlane senza specificare alcun argomento: verranno usati tutti i valori predefiniti. Oppure possiamo specificare per nome gli argomenti che vogliamo siano diversi dal comportamento predefinito, si vedano di seguito alcuni esempi.
Esempio
Si vedano tutti gli esempi seguenti.

### Point

Scopo
Crea un punto libero date le coordinate della sua posizione iniziale. Questo oggetto è la base di ogni costruzione; dai punti liberi dipendono, direttamente o indirettamente, gli altri oggetti grafici. Quando il puntatore del mouse si sovrappone ad un punto libero questo cambia colore. Trascinando un punto libero, con il mouse, tutti gli oggetti che dipendono da lui, verranno modificati. Point essendo un oggetto che può essere trascinato con il mouse ha un colore predefinito diverso da quello degli altri oggetti.
Sintassi
Point(x, y[, visible][, color][, width][, name])
Nota: Spesso nella pratica è necessario assegnare l'oggetto creato ad un identificatore in modo da poter fare riferimento ad un oggetto nella costruzione di altri oggetti:
<identificatore> = Point(x, y[, visible][, color][, width][, name])
Si vedano gli esempi seguenti.
Osservazioni
* x e y sono due numeri, x è l'ascissa e y l'ordinata del punto.
* Per quanto riguarda i parametri non obbligatori si veda quanto scritto nel paragrafo relativo agli attributi degli oggetti visibili.
Nota: Nel resto del manuale riporterò solo gli argomenti obbligatori, è sottinteso che tutti gli oggetti che possono essere visualizzati hanno anche i parametri: visible, color, width, name.
Esempio
Funzione definita in N ad andamento casuale.
import random
ip = ig.InteractivePlane('Point')
y = 0
for x in range (-14, 14):
y += random. randrange (-1 , 2)
ig.Point(x, y, color ='red')

### Attributi degli oggetti geometrici

Scopo
Point, come tutti gli oggetti geometrici ha degli attributi che possono essere determinati nel momento della creazione dell'oggetto stesso o in seguito. Questi attributi definiscono alcune caratteristiche degli oggetti che possono essere visualizzati.
* visible stabilisce se l'oggetto sarà visibili o invisibile.
* color imposta il colore dell'oggetto.
* width imposta la larghezza dell'oggetto.
* name imposta il nome dell'oggetto.
Sintassi
<oggetto>.visible = v
<oggetto>.color = c
<oggetto>.width = w
<oggetto>.name = s
Osservazioni
* v è un valore booleano, può essere True o False.
* w è un numero che indica la larghezza in pixel.
* c può essere:
** Una stringa nel formato: “#rrggbb” dove rr, gg e bb sono numeri esadecimali di due cifre che rappresentano rispettivamente le componenti rossa, verde, e blu del colore.
** Una stringa contenente il nome di un colore.
** Una terna di numeri nell'intervallo 0-1 rappresentanti le componenti rossa verde e blu.
* s è una stringa.
Esempio
Disegna tre punti: uno con i valori di default, uno con colore dimensione e nome definiti quando viene creato, uno con valori cambiati dopo essere stato creato.
ip = ig.InteractivePlane('attributi')
a = ig.Point(-5, 3)
b = ig.Point(2, 3, color ='indian red', width=8, name='B')
c = ig.Point(9, 3)
c.color ='dark orange'
c.width = 8
c.name = 'C'

### Metodi degli oggetti geometrici

Scopo
Tutti gli oggetti geometrici hanno anche dei metodi che danno come risultato alcune informazioni relative all'oggetto stesso.
* xcoord l'ascissa.
* ycoord l'ordinata.
* coords le coordinate.
Sintassi
<oggetto>.xcoord
<oggetto>.ycoord
<oggetto>.coords
Osservazioni
Non richiedono argomenti e restituiscono un particolare oggetto che può essere utilizzato all'interno di un testo variabile.
Esempio
Scrivi ascissa, ordinata e posizione di un punto.
ip = ig.InteractivePlane('coords, xcoord, ycoord')
a = ig.Point(-5, 8, name='A')
ig.VarText(-5, -1, 'ascissa di A: {0}', a.xcoord)
ig.VarText (-5, -2, 'ordinata di A: {0}', a.ycoord)
ig.VarText (-5, -3, 'posizione di A: {0}', a.coords)

### Segment

Scopo
Crea un segmento dati i due estremi, i due estremi sono punti.
Sintassi
<identificatore> = Segment(point0, point1)
Osservazioni
point0 e point1 sono due punti.
Esempio
Disegna un triangolo con i lati colorati in modo differente.
ip = ig.InteractivePlane('Segment')
# creo i 3 vertici
v0 = ig.Point(-4, -3, width=5)
v1 = ig.Point(5, -1, width=5)
v2 = ig.Point(2, 6, width=5)
# creo i 3 lati
l0 = ig.Segment(v0, v1, color ='steel blue')
l1 = ig.Segment(v1, v2, color ='sea green')
l2 = ig.Segment(v2, v0, color ='saddle brown')

### length

Scopo
È il metodo della classe Segment che restituisce un oggetto data contenente la lunghezza del segmento stesso.
Sintassi
<obj>.length
Osservazioni
La lunghezza è la distanza tra point0 e point1.
Esempio
Disegna un segmento e scrivi la sua lunghezza.
ip = ig.InteractivePlane('length')
p0 = ig.Point(-4, 7, width=5, name='A')
p1 = ig.Point(8, 10, width=5, name='B')
seg = ig.Segment(p0, p1)
ig.VarText(-5, -5, 'lunghezza di AB = {0}', seg.length)

### MidPoints

Scopo
Crea il punto medio tra due punti.
Sintassi
MidPoints(point0, point1)
Osservazioni
point0 e point1 sono due punti.
Esempio
Punto medio tra due punti.
ip = ig.InteractivePlane('MidPoints')
# creo due punti
p0 = ig.Point(-2, -5)
p1 = ig.Point(4, 7)
# cambio i loro attributi
p0.color = "#00a600"
p0.width = 5
p1.color = "#006a00"
p1.width = 5
# creao il punto medio tra p0 e p1
m = ig.MidPoints(p0, p1, name='M')
# cambio gli attributi di m
m.color = "#f0f000"
m.width = 10

### MidPoint

Scopo
Crea il punto medio di un segmento.
Sintassi
MidPoint(segment)
Osservazioni
segment è un oggetto che ha un point0 e un point1.
Esempio
Punto medio di un segmento.
ip = ig.InteractivePlane('MidPoint')
# creo un segmento
s = ig.Segment(ig.Point(-2, -1, color ="#a60000", width =5),
ig.Point(5, 7, color ="#6a0000", width =5),
color ="#a0a0a0")
# creo il suo punto medio
ig.MidPoint(s, color ="#6f6f00", width=10, name='M')

### Line

Scopo
Crea una retta per due punti.
Sintassi
Line(point0, point1)
Osservazioni
point0 e point1 sono, indovina un po', due punti.
Vedi anche i metodi delle classi linea presentati nella classe Segment.
Esempio
Triangolo delimitato da rette.
ip = ig.InteractivePlane('Line')
# creo i 3 punti
a = ig.Point(0, 0)
b = ig.Point(1, 5)
c = ig.Point(5, 1)
# creo i 3 lati
ig.Line(a, b, color ="#dead34")
ig.Line(b, c, color ="#dead34")
ig.Line(c, a, color ="#dead34")

### Ray

Scopo
Traccia una semiretta con l'origine in un punto e passante per un altro punto.
Sintassi
Ray(point0, point1)
Osservazioni
point0 è l'origine della semiretta che passa per point1.
Vedi anche i metodi delle classi linea presentati nella classe Segment.
Esempio
Triangolo delimitato da semirette.
ip = ig.InteractivePlane('Ray')
# creo i 3 punti
a = ig.Point(0, 0)
b = ig.Point(1, 5)
c = ig.Point(5, 1)
# creo i 3 lati
ig.Ray(a, b, color ="#de34ad")
ig.Ray(b, c, color ="#de34ad")
ig.Ray(c, a, color ="#de34ad")

### Orthogonal

Scopo
Crea la retta perpendicolare ad una retta data passante per un punto.
Sintassi
Orthogonal(line, point)
Osservazioni
line è la retta alla quale si costruisce la perpendicolare passante per point.
Vedi anche i metodi delle classi linea presentati nella classe Segment.
Esempio
Disegna la perpendicolare ad una retta data passante per un punto.
ip = ig.InteractivePlane('Orthogonal')
retta = ig.Line(ig.Point(-4, -1, width =5),
ig.Point(6, 2, width =5),
width=3, color ='DarkOrange1', name='r')
punto = ig.Point(-3, 5, width=5, name='P')
ig.Orthogonal(retta, punto)

### Parallel

Scopo
Crea la retta parallela ad una retta data passante per un punto.
Sintassi
Parallel(line, point)
Osservazioni
line è la retta alla quale si costruisce la parallela passante per point.
Vedi anche i metodi delle classi linea presentati nella classe Segment.
Esempio
Disegna la parallela ad una retta data passante per un punto.
ip = ig.InteractivePlane('Parallel')
retta = ig.Line(ig.Point(-4, -1, width =5),
ig.Point(6, 2, width =5),
width=3, color ='DarkOrange1', name='r')
punto = ig.Point(-3, 5, width=5, name='P')
ig.Parallel(retta, punto)

### Polygon

Scopo
Crea un poligono data una sequenza di vertici.
Sintassi
Polygon(points)
Osservazioni
points è una sequenza di punti, può essere una lista (delimitata da parentesi quadre) o una tupla (delimitata da parentesi tonde).
Esempio
Disegna un poligono date le coordinate dei vertici.
ip = ig.InteractivePlane('24: Polygon')
# Lista di coordinate
coords = ((-8, -3), (-6, -2), (-5, -2), (-4, 2), (-2, 3), (0, 4),
(2, 3), (4, 2), (5, -2), (6, -2), (8, -3))
# Costruzione di una lista di punti partendo da una lista di coordinate :
# listcompreension
ip.defwidth = 5
points = [ig.Point(x, y) for x , y in coords]
ig.Polygon(points, color = 'HotPink3')

### perimeter e surface

Scopo
Sono metodi presenti in tutte le classi figura, restituiscono la lunghezza del contorno e l'area della superficie dell'oggetto.
Sintassi
<figura>.perimeter
<figura>.surface
Osservazioni
Sono metodi degli oggetti che sono figure piane e non richiede argomenti.
Esempio
Scrive alcune informazioni relative a un poligono.
poli = ig.Polygon((ig.Point(-7, -3, width=5, name="A"),
ig.Point(5, -5, width=5, name="B"),
ig.Point(-3, 8, width=5, name="C")),
width=4, color ='magenta', intcolor ='olive drab')
ig.VarText(-3, -6, "perimetro ={0}", poli.perimeter, color ='magenta')
ig.VarText(-3, -7, "area ={0}", poli.surface, color ='olive drab')

### Circle

Scopo
Circonferenza dato il centro e un punto o il centro e il raggio (un segmento).
Sintassi
Circle(center, point)
Circle(center, segment)
Osservazioni
center è il centro della circonferenza passante per point o di raggio segment.
Vedi anche i metodi delle classi figure piane presentati nella classe Polygon.
Esempio
Circonferenze con centro nell'origine.
ip = ig.InteractivePlane('Circle(Point, Point)')
origine = ig.Point(0, 0, visible =False, name="O")
p0 = ig.Point(-7, -3, width=5, name="P")
ig.Circle(origine, p0, color ="#c0c0de", width=4)
raggio = ig.Segment(ig.Point(-7, 9, width=5, name="A"),
ig.Point(-4, 9, width=5, name="B"))
ig.Circle(origine, raggio, color ="#c0c0de", width=4)

### Intersection

Scopo
Crea il punto di intersezione tra due oggetti.
Sintassi
Intersection(obj0, obj1)
Intersection(obj0, obj1, which)
Osservazioni obj0 e obj1 possono essere rette o circonferenze. Se uno dei due oggetti è una circonferenza è necessario specificare quale delle due intersezioni verrà restituita indicando come terzo parametro +1 o -1.
Esempio
Disegna una circonferenza tangente a una retta.
ip = ig.InteractivePlane('Intersectionlineline')
# Disegno retta e punto
retta = ig.Line(ig.Point(-4, -1, width =5),
ig.Point(6, 2, width =5),
width=3, color ='DarkOrange1', name='r')
punto = ig.Point(-3, 5, width=5, name='P')
# trovo il punto di tangenza
perpendicolare = ig.Orthogonal(retta, punto, width=1)
p_tang = ig.Intersection(retta, perpendicolare, width=5)
# disegno la circonferenza
ig . Ci r c l e ( punto , p_tang , width=4 , color = ' IndianRed ' )
Disegna il simmetrico di un punto rispetto ad una retta.
ip = ig.InteractivePlane('Intersectionlinecircle')
# disegno l'asse di simmetria e il punto
asse = ig.Line(ig.Point(-4, -11, width =5),
ig.Point(-2, 12, width =5),
width=3, color ='DarkOrange1', name='r')
punto = Point(-7, 3, width=5, name='P')
# disegno la perpendi colare all'asse passante per il punto
perp = ig.Orthogonal(asse, punto, width=1)
# trovo l'intersezione tra la perpendicolare e l'asse
piede = ig.Intersection(perp, asse)
# disegno la circonferenza di centro piede e passante per punto
circ = ig.Circle(piede, punto, width=1)
# trovo il simmetrico di punto rispetto a asse
ig.Intersection(perp, circ, -1, width=5, color ='DebianRed', name="P'")
Disegna un triangolo equilatero.
ip = ig.InteractivePlane('Intersection circle circle')
# Disegno i due primi vertici
v0 = ig.Point(-2, -1, width=5, name='A')
v1 = ig.Point(3, 2, width=5, name='B')
# Disegno le due circonferenze di centro p0 e p1 e passanti per p1 e p0
c0 = ig.Circle(v0, v1, width=1)
c1 = ig.Circle(v1, v0, width=1)
# terzo vertice: intersezione delle due circonferenze
v2 = ig.Intersection(c0, c1, 1, width=5, name='C')
# triangolo per i 3 punti
ig.Polygon((v0, v1, v2), width=4, color ='DarkSeaGreen4')

### Text

Scopo
Crea un testo posizionato in un punto del piano.
Sintassi
Text(x, y, text[, iplane=None])
Osservazioni
* x e y sono due numeri interi o razionali relativi; x è l'ascissa e y l'ordinata del punto.
* text è la stringa che verrà visualizzata.
* Se sono presenti più piani interattivi, si può specificare l'argomento iplane per indicare in quale di questi la scritta deve essere visualizzata.
Esempio
Scrive un titolo in due finestre grafiche.
ip0 = ig.InteractivePlane('Text pale green', w=400, h=200)
ip1 = ig.InteractivePlane('Text blue violet', w=400, h=200)
ig.Text(-2, 2, "Prove di testo blue violet",
color = 'blue violet', width =20)
ig.Text(-2, 2, "Prove di testo pale green",
color = 'pale green', width=20, iplane=ip0)

### VarText

Scopo
Crea un testo variabile. Il testo contiene dei “segnaposto” che verranno sostituiti con i valori prodotti dai dati presenti nel parametro variables.
Sintassi
VarText(x, y, text, variables[, iplane=None])
Osservazioni
* x e y sono due numeri interi o razionali relativi x è l'ascissa e y l'ordinata del punto.
* text è la stringa che contiene la parte costante e i segnaposto.
* In genere i segnaposto saranno nella forma: “{0}” che indica a Python di convertire in stringa il risultato prodotto dal dato.
* variables è un dato o una tupla di dati.
* Se sono presenti più piani interattivi, si può specificare l'argomento iplane per indicare in quale di questi la scritta deve essere visualizzata.
Esempio
Un testo che riporta la posizione di un punto.
ip = ig.InteractivePlane('VarText')
p0 = ig.Point(7, 3, color ='green', width=10, name='A')
ig.VarText(-4, -3, "Posizione del punto A: ({0}; {1})",
(p0.xcoord, p0.ycoord),
color ='green', width =10)

### PointOn

Scopo Punto disegnato su un oggetto in una posizione fissa.
Sintassi
PointOn(obj, parameter)
Osservazioni
L'oggetto deve essere una linea o una retta o una circonferenza, parameter è un numero che individua una precisa posizione sull'oggetto. Sia le rette sia le circonferenze hanno una loro metrica che è legata ai punti base dell'oggetto. Su una retta una semiretta o un segmento point0 corrisponde al parametro 0 mentre point1 corrisponde al parametro 1. Nelle circonferenze il punto di base della circonferenza stessa corrisponde al parametro 0 l'intera circonferenza vale 2. Il punto creato con PointOn non può essere trascinato con il mouse.
Esempio
Disegna il simmetrico di un punto rispetto ad una retta.
ip = ig.InteractivePlane('PointOn')
# disegno l'asse di simmetria e il punto
asse = ig.Line(ig.Point(-4, -11, width =5),
ig.Point(-2, 12, width =5),
width=3, color ='DarkOrange1', name='r')
punto = ig.Point(-7, 3, width=5, name='P')
# disegno la perpendicolare all'asse passante per il punto
perp = ig.Orthogonal(asse, punto, width=1)
# trovo il simmetrico di punto rispetto a asse
ig.PointOn(perp, -1, width=5, color ='DebianRed', name="P'")
ig.Text(-5, -6, """P' e'il simmetrico di P.""")

### ConstrainedPoint

Scopo
Punto legato ad un oggetto.
Sintassi
ConstrainedPoint(obj, parameter)
Osservazioni
Per quanto riguarda parameter, valgono le osservazioni fatte per PoinOn. Questo puntoperò può essere trascinato con il mouse pur restando sempre sull'oggetto. Dato che può essere trascinato con il mouse ha un colore di default diverso da quello degli altri oggetti.
Esempio
Circonferenza e proiezioni sugli assi.
ip = ig.InteractivePlane('ConstrainedPoint', sx =200)
# Circonferenza
origine = ig.Point(0, 0, visible =False)
unix = ig.Point(1, 0, visible =False)
uniy = ig.Point(0, 1, visible =False)
circ = ig.Circle(origine, unix, color ="gray10")
# Punto sulla circonferenza
cursore = ig.ConstrainedPoint(circ, 0.25, color ='magenta', width=20)
# assi
assex = Line(origine, unix, visible =False)
assey = Line(origine, uniy, visible =False)
# proiezioni
py = ig.Parallel(assey, cursore, visible =False)
hx = ig.Intersection(assex, py, color ='red', width=8)
px = ig.Parallel(assex, cursore, visible =False)
hy = ig.Intersection(assey, px, color ='blue', width=8)

### parameter

Scopo
I punti legati agli oggetti hanno un metodo che permette di ottenere il parametro.
Sintassi
<constrained point>.parameter
Osservazioni
In PointOn il parametro è fissato nel momento della costruzione dell'oggetto. In ConstrainedPoint il parametro può essere variato trascinando il punto con il mouse.
Esempio
Scrivi i dati relativi a un punto collegato a un oggetto.
ip = ig.InteractivePlane('parameter')
c0 = ig.Circle(ig.Point(-6, 6, width =6), ig.Point(-1, 5, width =6))
c1 = ig.Circle(ig.Point(6, 6, width =6), ig.Point(1, 5, width =6 ))
a = ig.PointOn(c0, 0.5, name='A')
b = ig.ConstrainedPoint(c1, 0.5, name='B')
ig.VarText(-5, -1, 'ascissa di A: {0}', a.xcoord)
ig.VarText(-5, -2, 'ordinata di A: {0}', a.ycoord)
ig.VarText(-5, -3, 'posizione di A: {0}', a.coords)
ig.VarText(-5, -4, 'parametro di A: {0}', a.parameter)
ig.VarText(5, -1, 'ascissa di B: {0}', b.xcoord)
ig.VarText(5, -2, 'ordinata di B: {0}', b.ycoord)
ig.VarText(5, -3, 'posizione di B: {0}', b.coords)
ig.VarText(5, -4, 'parametro di B: {0}', b.parameter)

### Angle

Scopo
Angolo dati tre punti o due punti e un altro angolo. Il secondo punto rappresenta il vertice.
Il verso di costruzione dell'angolo è quello antiorario.
Sintassi
Angle(point0, vertex, point1[, sides])
Angle(point0, vertex, angle[, sides])
Osservazioni
L'argomento sides può valere:
* True(o(0, 1)): vengono disegnati i lati.
* 0: viene disegnato il lato 0.
* 1: viene disegnato il lato 1.
Angle fornisce i seguenti metodi dal significato piuttosto evidente:
* extent: ampiezza dell'angolo.
* bisector: bisettrice.
Esempio
Disegna un angolo e un angolo con i lati.
ip = ig.InteractivePlane('Angle(Point, Point, Point)')
ip.defwidth = 5
a = ig.Point(-2, 4, color ="#40c040", name="A")
b = ig.Point(-5, -2, color ="#40c040", name="B")
c = ig.Point(-8, 6, color ="#40c040", name="C")
d = ig.Point(8, 6, color ="#40c040", name="D")
e = ig.Point(5, -2, color ="#40c040", name="E")
f = ig.Point(2, 4, color ="#40c040", name="F")
# angolo senza i lati
ig.Angle(a, b, c, color ="#40c040")
# angolo con i lati
ig.Angle(d, e, f, color ="#c04040", sides=True)
Somma di due angoli.
ip = ig.InteractivePlane('Angle(Point, Point, Angle)')
# i 2 angoli di partenza
a = ig.Angle(ig.Point(-3, 7, width =6),
ig.Point(-7, 5, width =6),
ig.Point(-6, 8, width =6),
sides =(0,1), color ="#f09000", name='alfa')
b = ig.Angle(ig.Point(9, 2, width =6),
ig.Point(2, 3, width =6),
ig.Point(6, 4, width =6),
sides =(0, 1), color ="#0090f0", name='beta')
# Punti di base dell'angolo somma di a b
v = ig.Point(-11, -8, width=6)
p0 = ig.Point(3, -10, width=6)
# la somma degli angoli
b1 = ig.Angle(p0, v, b, (0,1), color ="#0090f0")
p1 = b1.point1
a1 = ig.Angle(p1, v, a, sides=True, color ="#f09000")
ig.Text(-4, -12, "Somma di due angoli")

### Bisector

Scopo
Retta bisettrice di un angolo.
Sintassi
<Bisector>(<angle>)
Osservazioni
Vedi Ray.
Esempio
Disegna l'incentro di un triangolo.
ip = ig.InteractivePlane('Bisector')
# I tre vertici del triangolo
a = ig.Point(-7, -3, color ="#40c040", width=5, name="A")
b = ig.Point( 5, -5, color ="#40c040", width=5, name="B")
c = ig.Point(-3, 8, color ="#40c040" , width=5, name="C")
# Il triangolo
ig.Polygon((a, b, c))
# Due angoli del triangolo
cba = ig.Angle(c, b, a)
bac = ig.Angle(b, a, c)
# Le bisettrici dei due angoli
b1 = ig.Bisector(cba, color ="#a0c040")
b2 = ig.Bisector(bac, color ="#a0c040")
# L'incentro
ig.Intersection(b1, b2, color ="#c040c0", width=5, name="I")

### Calc

Scopo
Dato che contiene il risultato di un calcolo.
Sintassi
Calc(function, variables)
Osservazioni
* function è una funzione python, al momento del calcolo, alla funzione vengono passati come argomenti il contenuto di variables.
* variables è un oggetto Data o una tupla che contiene oggetti Data. Il risultato è memorizzato all'interno dell'oggetto Calc e può essere visualizzato con VarText o utilizzato per definire la posizione di un punto.
Esempio
Calcola il quadrato di un lato e la somma dei quadrati degli altri due di un triangolo.
ip = ig.InteractivePlane('Calc')
ig.Circle(ig.Point(2, 4), ig.Point(-3, 4), width=1)
ip.defwidth = 5
a = ig.Point(-3, 4, name="A")
b = ig.Point(7, 4, name="B")
c = ig.Point(-1, 8, name="C")
ab = ig.Segment(a, b, color ="#40c040")
bc = ig.Segment(b, c, color ="#c04040")
ca = ig.Segment(c, a, color ="#c04040")
q1 = ig.Calc(lambda a: a*a, ab.length)
q2 = ig.Calc(lambda a, b: a*a+b*b, (bc.length, ca.length))
ig.VarText(-5, -5, "ab^2 = {0}", q1, color ="#40c040")
ig.VarText(-5, -6, bc^2 + ca^2 = {0}", q2, color ="#c04040")
Riassumendo
* In questo paragrafo sono stati presentati i seguenti oggetti.
** Angle Angolo dati tre punti o due punti e un angolo, il secondo punto rappresenta il vertice. Il verso di costruzione dell'angolo è quello antiorario.
** Bisector Retta bisettrice di un angolo.
** Circle Circonferenza dato il centro e un punto o il centro e un raggio (un segmento).
** ConstrainedPoint Punto legato ad un oggetto.
** Calc Dato che contiene il risultato di un calcolo.
** InteractivePlane Crea il piano cartesiano e inizializza gli attributi del piano.
** Intersection Crea il punto di intersezione tra due rette.
** Line Crea una retta per due punti.
** MidPoint Crea il punto medio di un segmento
** MidPoints Crea il punto medio tra due punti.
** Orthogonal Crea la retta perpendicolare ad una retta data passante per un punto.
** Parallel Crea la retta parallela ad una retta data passante per un punto.
** Point Crea un punto libero date le coordinate della sua posizione iniziale.
** PointOn Punto disegnato su un oggetto in una posizione fissa.
** Polygon Crea un poligono data una sequenza di vertici.
** Ray Traccia una semiretta con l'origine in un punto e passante per un altro punto.
** Segment Crea un segmento dati i due estremi, i due estremi sono punti.
** Text Crea un testo posizionato in un punto del piano.
** VarText Crea un testo variabile. Il testo contiene dei “segnaposto” che verranno sostituiti con i valori prodotti dai dati presenti nel parametro variables.
* In questo paragrafo sono stati presentati i seguenti attributi.
** <oggetto_visibile>.color Attributo degli oggetti geometrici: imposta il colore dell'oggetto;
** <oggetto_visibile>.name Attributo degli oggetti geometrici: imposta il nome dell'oggetto.
** <oggetto_visibile>.visible Attributo degli oggetti geometrici: stabilisce se l'oggetto sarà visibili o invisibile;
** <oggetto_visibile>.width Attributi degli oggetti geometrici: imposta la larghezza dell'oggetto.
* In questo paragrafo sono stati presentati i seguenti metodi.
** <circonferenza>.radius Metodo delle classi circonferenza che restituisce un oggetto data che contiene la lunghezza del raggio della circonferenza.
** <figura>.perimeter Metodo delle classi figura che restituisce un oggetto data contenente la lunghezza del contorno dell'oggetto.
** <figura>.surface Metodo delle classi figura che restituisce un oggetto data contenente l'area della superficie dell'oggetto.
** <oggetto_visibile>.coords Restituisce un dato che contiene le coordinate.
** <oggetto_visibile>.xcoord Metodo degli oggetti visualizzabili: restituisce un dato che contiene l'ascissa.
** <oggetto_visibile>.ycoord Metodo degli oggetti visualizzabili: restituisce un dato che contiene l'ordinata.
** <punto_legato>.parameter Metodo dei punti legati agli oggetti che restituisce un oggetto data contenente il parametro.
** <segmento>.length Metodo della classe Segment che restituisce un oggetto data contenente la lunghezza del segmento stesso.