Rotazione¶

In questo capitolo si affrontano i seguenti argomenti:

Cos’è una rotazione e quali sono le sue proprietà.
Cosa sono gli elementi uniti in una rotazione.
Cosa sono le rotazione di un poligono regolare.
Cosa dice l’algebra sulle rotazioni.

Definizione¶

Una rotazione rispetto a un centro O è una trasformazione che fa ruotare attorno a O, ogni punto del piano di uno stesso angolo,

Una rotazione è determinata dal centro e dall’angolo.

La funzione principale è quella che dato un punto, un centro e un angolo costruisce la rotazione del punto. Per cui:

p_1 = RuotaPunto(punto, centro, angolo)

Ovviamente punto, centro e angolo dovranno essere rispettivamente il punto che vogliamo trasformare, il centro di rotazione e l’angolo di rotazione creati precedentemente. Dopo la chiamata, p_1 conterrà il riferimento al punto immagine di p_0 nella rotazione.

La funzione RuotaPunto(punto, centro, ang) dovrà:

creare una semiretta invisibile passante per centro e p_0;
su questa semiretta riportare l’angolo;
intersecare questa semiretta con una circonferenza centrata in centro e passante per p_0;
dare come risultato questa intersezione.

Una possibile soluzione:

def ruotapunto(punto, centro, angolo, **kargs):
    """Restituisce la rotazione di punto dati centro e angolo."""
    lato_0 = ig.Ray(centro, punto, width=1)
    ang = ig.Angle(punto, centro, angolo)
    lato_1 = ang.side1(width=1)
    circ = ig.Circle(centro, punto, width=1)
    return ig.Intersection(circ, lato_1, 1, **kargs)

Avviato IDLE creiamo una nuova finestra (menu-File-New window) e la salviamo, in una nostra cartella, con il nome rota01_proprieta.py. Inizia questo programma con un’intestazione adeguata: alcuni commenti che contengano la data, il nostro nome e un titolo.

Il programma potrà assomigliare a questo:

# Rotazioni: proprietà

# lettura delle librerie
import pyig as ig

# funzioni
def ruotapunto(punto, centro, angolo, **kargs):
    """Restituisce la rotazione di punto dati centro e angolo."""
    lato_0 = ig.Ray(centro, punto, width=1)
    ang = ig.Angle(punto, centro, angolo)
    lato_1 = ang.side1(width=1)
    circ = ig.Circle(centro, punto, width=1)
    return ig.Intersection(circ, lato_1, 1, **kargs)

# programma principale
ip = ig.InteractivePlane()

# Creo l'asse di simmetria
centro = ig.Point(-3, -2, width=6, name='O')
angolo = ig.Angle(ig.Point(-5, 10, width=6),
                  ig.Point(-10, 10, width=6),
                  ig.Point(-6, 12, width=6), name='alfa')
angolo.side0(width=1)
angolo.side1(width=1)

# Punto A e il suo punto ruotato
a_0 = ig.Point(6, -1, width=6, name="A")
a_1 = ruotapunto(a_0, centro, angolo, width=6, name="A'")

# attivazione della finestra grafica
ip.mainloop()

Eseguiamo il programma, muoviamo i punti base, il punto A' deve corrispondere al punto A nella rotazione. Se tutto funziona siamo pronti per esplorare le caratteristiche delle rotazioni.

Proprietà¶

Cambia l’angolo di rotazione, cosa avviene quando è di 360°?

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Quando l’angolo di rotazione è un multiplo di 360° la rotazione diventa una particolare trasformazione: l’identità.

Costruisci ora un nuovo punto B e B', il suo trasformato nella rotazione. Poi crea i segmenti AB e A'B' e visualizzane la misura. Puoi formulare la congettura: A'B' è congruente ad AB. Prova a dimostrarla.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Costruisci un punto P vincolato al segmento AB e il suo simmetrico P':

p = ig.ConstrainedPoint(ab, .3, width=6, color='olive drab', name="P")
p1 = simmpunto(p, asse, width=6, color='olive drab', name="P'")

Muovi il punto P, cosa osservi?

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Costruisci un nuovo punto C e C', costruisci il poligono ABC, e il poligono A'B'C'. Cosa si può concludere circa i triangoli ABC e A'B'C'?

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Cosa puoi dire sull’orientamento dei vertici del triangolo ABC e del suo trasformato A'B'C'?

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Riassumendo

La rotazione è una trasformazione geometrica che trasforma segmenti in segmenti congruenti, perciò è una isometria.
La rotazione mantiene il verso dei poligoni.
Se un punto appartiene ad un segmento, il suo ruotato appartiene al ruotato del segmento.

Il programma completo:

# Rotazioni: proprietà

# lettura delle librerie
import pyig as ig

# funzioni
def ruotapunto(punto, centro, angolo, **kargs):
    """Restituisce la rotazione di punto dati centro e angolo."""
    lato_0 = ig.Ray(centro, punto, width=1)
    ang = ig.Angle(punto, centro, angolo)
    lato_1 = ang.side1(width=1)
    circ = ig.Circle(centro, punto, width=1)
    return ig.Intersection(circ, lato_1, 1, **kargs)

# programma principale
ip = ig.InteractivePlane()

# # Creo il centro e l'angolo di rotazione
centro = ig.Point(-3, -2, width=6, name='O')
angolo = ig.Angle(ig.Point(-5, 10, width=6),
                  ig.Point(-10, 10, width=6),
                  ig.Point(-6, 12, width=6), name='alfa')
angolo.side0(width=1)
angolo.side1(width=1)

# Punto A e A'
a_0 = ig.Point(6, -1, width=6, name="A")
a_1 = ruotapunto(a_0, centro, angolo, width=6, name="A'")

# Punto B e B'
b_0 = ig.Point(7, 3, width=6, name="B")
b_1 = ruotapunto(b_0, centro, angolo, width=6, name="B'")

# I segmenti AB, A'B' e le loro misure
ab =ig.Segment(a_0, b_0, width=6, color='violet')
a1b1 =ig.Segment(a_1, b_1, width=6, color='violet')
ig.VarText(-7, -7, "AB = {}", ab.length())
ig.VarText(-7, -8, "A'B' = {}", a1b1.length())

# P vincolato alla retta AB
p_0 = ig.ConstrainedPoint(ab, .3, width=6,
                          color='olive drab', name="P")
p_1 = ruotapunto(p_0, centro, angolo, width=6,
                 color='olive drab', name="P'")

# Punto C, C', i triangoli ABC e A'B'C'
c_0 = ig.Point(-1, 1, width=6, name="B")
c_1 = ruotapunto(c_0, centro, angolo, width=6, name="C'")
ig.Polygon((a_0, b_0, c_0), width=4, color='violet', intcolor='gold')
ig.Polygon((a_1, b_1, c_1), width=4, color='violet', intcolor='gold')

# attivazione della finestra grafica
ip.mainloop()

Elementi uniti¶

Avvia un nuovo programma e salvarlo con il nome: rota02_elementiuniti.py e scrivi funzione ruotapunto(punto, centro, angolo, **kargs) che restituisce il corrispondente di un punto nella rotazione. Questa volta le linee di costruzione falle invisibili.

Quali sono gli elementi uniti di una rotazione?

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Riassumendo

In una trasformazione un elemento si dice unito se viene trasformato in se stesso.
In una rotazione sono elementi uniti:
- il punto . . . . . . . . . . . . . . .
- le circonferenze . . . . . . . . . . . . . . .

Equazioni di alcune rotazioni¶

Avvia un nuovo programma e salvarlo con il nome: rota03_equazioni.py. Scrivi la solita funzione ruotapunto(punto, centro, angolo, **kargs).

Nel programma principale crea:

un piano interattivo;
il centro di rotazione nell’origine degli assi;
l’angolo di rotazione di 90°;
un punto P e visualizza le sue coordinate;
il punto P' e visualizza le sue coordinate;
muovi il punto P in varie posizioni e completa la seguente tabella:

punto P	punto P’
P (-4; 3)	A’(. . . . . ; . . . . .)
P (1; -4)	B’(. . . . . ; . . . . .)
P (. . ; . . )	C’(. . . . . ; . . . . .)
P (x; y)	P’(. . . . . ; . . . . .)

Nella rotazione di 90° con centro nell’origine degli assi: l’ascissa del generico punto P' è . . . . . . . . . . . . . . . ; l’ordinata del generico punto P’, è . . . . . . . . . . . . . .

La rotazione di 90° con centro nell’origine si può tradurre nel sistema di equazioni: $\rho_{90} \left \{ \begin{array}{l} x' = \\ y' = \end{array} \right .$

In modo analogo esplora le rotazioni di 180°, 270° e 360°.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Riassumendo

il programma per studiare le rotazioni di 90° può essere fatto così:

# Rotazioni: equazioni della rotazione

# lettura delle librerie
import pyig as ig

# funzioni
def ruotapunto(punto, centro, angolo, **kargs):
    """Restituisce la rotazione di punto dati centro e angolo."""
    lato_0 = ig.Ray(centro, punto, visible=False)
    ang = ig.Angle(punto, centro, angolo)
    lato_1 = ang.side1(visible=False)
    circ = ig.Circle(centro, punto, visible=False)
    return ig.Intersection(circ, lato_1, 1, **kargs)

# programma principale
ip = ig.InteractivePlane()

# Creo il centro e l'angolo di rotazione
centro = ig.Point(0, 0, width=6, name='O')
angolo = ig.Angle(ig.Point(-5, 10, visible=False),
                  ig.Point(-10, 10, visible=False),
                  ig.Point(-10, 12, visible=False), name='alfa')
angolo.side0(width=1)
angolo.side1(width=1)

# Punto P e P' e le loro coordinate
p_0 = ig.Point(6, -1, width=6, name="P")
p_1 = ruotapunto(p_0, centro, angolo, width=6, name="P'")
ig.VarText(-7, -11, "P = {}", p_0.coords())
ig.VarText(-7, -12, "P' = {}", p_1.coords())

# attivazione della finestra grafica
ip.mainloop()

Certe rotazioni possono essere tradotte con un sistema di equazioni abbastanza semplice.
$\rho_{90} \left \{ \begin{array}{l} x' = \\ y' = \end{array} \right .$

$\rho_{180} \left \{ \begin{array}{l} x' = \\ y' = \end{array} \right .$
$\rho_{270} \left \{ \begin{array}{l} x' = \\ y' = \end{array} \right .$

$\rho_{360} \left \{ \begin{array}{l} x' = \\ y' = \end{array} \right .$

Prova tu

Sul quaderno completa le seguenti frasi.

Una rotazione è
In una rotazione figure corrispondenti sono
In una rotazione:
1. sono punti uniti
2. sono circonferenze unite
Le equazioni di alcune rotazioni sono: