movimentos.html

movimentos.html
movimentos.mws (save link as)

Movimentos no plano e operadores lineares

No plano e no espaço, parte dos movimentos pode ser descrita como um transformação linear do plano no plano ( ou do espaço no espaço), também chamdo operador linear do plano (ou do espaço). Na verdade, todo movimento rígido se escreve como composição de translações com transformações lineares. Além disso, utilizando coordenadas homogêneas, até as translações viram transformações lineares.

> with(linalg): #carregando o pacote de Algebra Linear

> with(plots): #carregando um pacote basico de graficos

> figura[0] := [[0,0],[1,0],[1,2]]: # vertices de um triangulo para serem aplicados os movimentos

> plotfigura[0] := polygonplot( figura[0], color=yellow): # plot da figura acima, original.

Movimentos rígidos do plano (sem coordenadas homogêneas)

1. Translação segundo um vetor v

Fixado o vetor v, a translação segundo v associa a cada ponto P o ponto P+v

P -> P+v

Se v é não nulo, a tranlação não é linear, pois O vai em O+v = v

> tau := (v,P) -> convert(evalm(P+v),list); função que a cada v e P associa P+v

> tau([3,2],[1,0]); exemplo: aplicando a translação de v=[3,2] no ponto P=[1,0]

> map2(tau,[3,3],figura[0]); aplicando a translação de v=[3,3] sobre os pontos de figura[0] dado acima

> polygonplot([figura[0], map2(tau,[3,2],figura[0])], color=yellow); desenhando a figura[0] e o seu transladado segundo o vetor v=[3,2]

> plotfigura[0] := polygonplot(figura[0], color=yellow): armazenando o desenho de figura[0] em plotfigura[0]

> plotfigura[1] := polygonplot(map2(tau,[3,2],figura[0]), color=green):

> display([plotfigura[0],plotfigura[1]], scaling=constrained); exibindo as duas figuras simultaneamente

> for i from 1 to 10 do

> plotfigura[i] := polygonplot(map2(tau, evalm(i/10*[3,2]),figura[0]), color=green):

> od: criando uma sequência de quadros da animação da translação

> display( [seq( plotfigura[i], i=0..10)], insequence=true, scaling=constrained); exibindo a animação

2. Rotação em torno da origem

A rotação de angulo t em torno da origem associa a cada P=(x,y)=(r cos s, r sen s) o ponto Q = (r cos(s+t), r sen(s+t))=(x cost - y sen t, x sen t + y cos t), o que pode ser obtido matricialmente com multiplicação por matriz. A rotação em torno da origem é portanto uma transformação linear, com matriz dada por:

> matrix(2,2,[cos(t),-sin(t),sin(t),cos(t)]);

> Rot := (t,P) -> convert( evalm( matrix(2,2,[cos(t),-sin(t),sin(t),cos(t)]) &* P), list); função que a cada rotaciona P de ângulo t em torno de O, com entradas t e P

> Rot( Pi/3, [1,0]); Rot(Pi/3, [0,1]); aplicando a rotação nos pontos [1,0] e [0,1]

> map2( Rot, Pi/3, figura[0]); aplicando a rotação de ângulo Pi/3 nos pontos de figura[0]

> plotfigura[1] := polygonplot( map2( Rot, Pi/3, figura[0]), color=green): armazenando o desenho do resultado da rotação.

> display([plotfigura[0],plotfigura[1]], scaling=constrained); exibindo a figura original e a rodada

> for i from 1 to 30 do

> plotfigura[i] := polygonplot( map2( Rot, (i/30)*(2*Pi),figura[0]), color=green, scaling=constrained):

> od: fabricando 30 quadros da animação da rotação de uma volta completa

> display( [seq( plotfigura[i], i=0..30)], insequence=true, scaling=constrained);

>

3. Reflexão em relação a uma reta pela origem

3.1 Em relação ao eixo Ox

Esta reflexão leva P=(x,y) em Q=(x,-y) e portanto é uma transformação linear cuja matriz é

> matrix(2,2,[1,0,0,-1]);

> Rx := P -> convert(evalm(matrix(2,2,[1,0,0,-1])&*P), list); função que reflete P em relação ao eixo Ox

> Rx([x,y]); Rx([1,2]);

> plotfigura[1] := polygonplot( map( Rx, figura[0]), color=green):

> display([plotfigura[0],plotfigura[1]], scaling=constrained);

> figura[20] := map(Rx,figura[0]);

> for i from 1 to 20 do

> plotfigura[i] := display({polygonplot(evalm(figura[0]+i/20*(figura[20]-figura[0])), color=green)}):

> od:

> display( [seq( plotfigura[i], i=0..20)], insequence=true, scaling=constrained);

3.2 Reflexão em relação a uma reta que passa pela origem e tem direção do vetor v=[a,b]

Este movimento é uma composição de uma rotação Rot(-t) com a reflexão Rx seguida da rotação Rot(t), onde t é o angulo entre Ox e v.

(a matriz de Rot(t) é a mesma matriz que aparece se utilizasse mudança de base.)

Sendo dado v=[a,b], é facil obter a matriz de Rot(t). que é uma matriz ortogonal cuja primeira coluna é o versor de v. Sua inversa é a transposta.

> v :=[1,2]: v1 := evalm(v/norm(v,2)): # v1 é o versor de v

> versor := v -> evalm(v/ norm(v,2)); função versor

> versor(v);

> ortver := v -> evalm([ -v[2],v[1]]/norm(v,2)); função que a cada v associa um vetor unitário normal ao seu versor.

> ortver(v);

> Rotv := v -> concat(versor(v),ortver(v)); função que a cada v associa a matriz da rotação que leva [1,0] em v1

> Rotv(v);

> MRefl :=v-> evalm(Rotv(v) &* matrix(2,2,[1,0,0,-1]) &* transpose(Rotv(v))); a função MRefl associa a cada v a matriz da reflexão segundo a reta dada

> MRefl([a,b]);

> Refl := (v,P) -> convert(evalm(MRefl(v) &* P), list);

> map2( Refl, [1,2], figura[0]);

> plotreta:=plot( [[-v1[1],-v1[2]], [v1[1],v1[2]]], color=red, thickness=2, scaling=constrained):

> plotfigura[1] := polygonplot( map2( Refl,[1,2], figura[0]), color=green):

> display([plotfigura[0],plotfigura[1],plotreta], scaling=constrained);

> figura[20]:= map2(Refl,v,figura[0]);

> polygonplot(evalm(figura[0]+1/3*(figura[20]-figura[0])));

> for i from 1 to 20 do

> plotfigura[i]:=display({plotreta,polygonplot(evalm(figura[0]+i/20*(figura[20]-figura[0])), color=green)}):

> od:

> display( [seq( plotfigura[i], i=0..20)], scaling=constrained);

> display( [seq( plotfigura[i], i=0..20)], insequence=true, scaling=constrained);

3.3. Reflexão em relação a uma reta pela origem dada pela equação geral: ax+by =0

Neste caso, conhece-se o vetor normal u = [a,b] da reta.

Então a reflexão pode ser mais facilmente obtida lembrando que ela leva um ponto P em Q = P - 2 Proj(OP,u), onde Proj(OP,u) é a projeção ortogonal do vetor OP sobre o vetor normal u. Temos também de Geometria Analitica, que Proj(OP,u) = <OP,u>/<u,u> u. O produto <u,v> é o produto escalar entre os vetores u e v, também conhecido como produto interno de u e v, em Algebra Linear.

> u := [-2,1]: u1 := evalm(u/norm(u,2)):

> plotreta := plot([[u1[2],-u1[1]], [-u1[2],u1[1]]], color=red, thickness=2):

> Proj := (v,u)-> evalm(dotprod(v,u)/dotprod(u,u)*u); função que projeta ortogonalmente v sobre u

> Proj([x,y],u);

> Refl2 := (u,P) -> convert(evalm(P-2*Proj(P,u)),list); função que a cada P associa o seu refletido em relação à reta normal a u passando por O.

> map2(Refl2,[-2,1],figura[0]);

> plotfigura[1] := polygonplot( map2( Refl2,u, figura[0]), color=green):

> display([plotfigura[0],plotfigura[1],plotreta], scaling=constrained);

>

> figura[20]:= map2(Refl2,u,figura[0]);

> for i from 0 to 20 do

> plotfigura[i]:=display({plotreta,polygonplot(evalm(figura[0]+i/20*(figura[20]-figura[0])), color=green)}):

> od:

> display( [seq( plotfigura[i], i=0..20)], scaling=constrained);

> display( [seq( plotfigura[i], i=0..20)], insequence=true, scaling=constrained);

4. Rotação em torno de um ponto C fora da origem

Sendo C=(c1, c2) o ponto fora da origem, a rotação de angulo t em torno de C pode ser escrita como composição de 3 movimentos, na ordem:

1. tau(-OC): Translação de -OC=(-c1,-c2) que leva C na origem

2. Rot(t): Rotação de angulo t em torno da origem

3. tau(OC): Translação de OC=(c1,c2) que leva origem em C

Ou seja, um ponto P é levado em P1 = P -OC=tau(-OC,P), que é levado em Rot(t,P1)=P2, que finalmente é levado em Q=tau(OC,P2).

Logo, Q = tau(OC, Rot(t, tau(-OC,P))).

>

> C := [2,1]:

> RotC := (t,P) -> tau([C[1], C[2]], Rot(t, tau([-C[1],-C[2]], P)));

> centro:=pointplot(C, color=red):

> figura[1] := map2(RotC,Pi/3, figura[0]);

> plotfigura[0] := polygonplot( figura[0], color=yellow):

> plotfigura[1]:=polygonplot(figura[1], color=green):

> display({plotfigura[0], plotfigura[1], centro}, scaling=constrained);

> for i from 0 to 30 do

> poligono := polygonplot( map2( RotC, (i/30)*(2*Pi),figura[0]), color=green, scaling=constrained): plotfigura[i] := display({poligono,centro}):

> od:

> display( [seq( plotfigura[i], i=0..30)], insequence=true, scaling=constrained);

5. Reflexão em relação a uma reta qualquer do plano

Também neste caso, obtemos o movimento como composição de 3 movimentos:

1. Translacão que leva a reta para uma reta passando pela origem (basta escolher um ponto A da reta e fazer a tranlação por -OA)

2. Reflexão segundo a reta pela origem obtida em 1.

3. Translação por OA

5.1. Se a reta passa pelos pontos A e B e portanto tenho um ponto A e um vetor v=AB da reta,

um ponto P é levado em Q = tau(OA, Refl( v, tau( -OA, P))), onde Refl( v, P) representa o refletido de P em relação à reta pela origem com direção de v.

> A := [1,0]: B:= [0,1]:

> v := evalm(B-A);

> Refl3 := P -> tau( A, Refl(v, tau([-A[1],-A[2]], P)));

> Refl3( [x,y]);

> map(Refl3,figura[0]);

> Reflpol := proc(A,B,pol)

> local v, refl:

> v := evalm(B-A):

> refl := P -> tau( A, Refl(v, tau([-A[1],-A[2]], P))):

> map(refl, pol): end proc:

>

> Reflpol([2,1],[0,1],figura[0]); # exemplo

> plotfigura[0] := polygonplot(figura[0], color=yellow):

> reta := plot([A,B], thickness=2, color=red):

> plotfigura[20] := polygonplot(Reflpol(A,B,figura[0]), color=green):

> display({plotfigura[0], plotfigura[20], reta}, scaling=constrained);

5.2 Reflexão segundo reta ax + by +c =0

Encontrando um ponto A da reta, sua normal sendo u=[a,b], leva o ponto P em Q = tau(OA, Refl2(u, tau(-OA, P))), onde Refl2(u, P) representa o refletido de P em relação à reta pela origem que tem normal u.

> A := [0,1]: u:= [1,1]:

> Reflpol2 := proc(A,u,pol)

> local v, refl:

> v := evalm(B-A):

> refl := P -> tau( A, Refl2(u, tau([-A[1],-A[2]], P))):

> map(refl, pol): end proc:

> Reflpol2([2,1],[0,1],figura[0]); # exemplo

> reta := implicitplot(u[1]*x+u[2]*y-u[1]*A[1]-u[2]*A[2]=0, x=0..4, y=0..4, thickness=3, color=red):

> plotfigura[20] := polygonplot(Reflpol2(A,u,figura[0]), color=green):

> display({plotfigura[0], plotfigura[20], reta}, scaling=constrained);

>

Movimentos rígidos do plano, com uso de coordenadas homogêneas.

Vamos considerar o plano Oxy mergulhado no espaço Oxyz: (x,y) -> (x,y,1)

Dizemos que estamos utilizando coordenadas homogêneas, melhor representado por (x : y :1) devido à identificação que fazemos do espaço com o plano projetivo . Veja as observações abaixo.

> restart; with(linalg): with(plots):

Warning, the protected names norm and trace have been redefined and unprotected

Warning, the name changecoords has been redefined

> figura[0] := [[0,0],[1,0],[1,2]]:

> plotfigura[0] := polygonplot(figura[0], color=yellow):

Observações - o espaço e o plano projetivo

Na verdade, o espaço em questão pode ser interpretado como uma representação do plano projetivo , onde toda reta passando pela origem representa um único ponto de . Ou seja, cada reta : representa um único ponto (a : b: c) em . Cada ponto do plano z=1 correspondente ao nosso plano mergulhado corresponde a uma reta do espaço passando pela origem que não está no plano z=0 [pontos ( : : 1)]. As retas pela origem contidas no plano z=0 do espaço representam "pontos no infinito" de [pontos (a : b: 0) que pertencem a ].

Este plano projetivo possui uma geometria diferente da euclidiana, pois não existem retas paralelas. Todo par de retas distintas são concorrentes. As retas paralelas do plano euclidiano correspondem a retas que se encontram no "infinito". E também não vale a noção de "um ponto está entre os outros dois" pois toda reta é no fundo uma curva fechada como uma circunferência.

6. Translações no plano e operadores lineares do espaço

Dada uma translação do plano segundo o vetor v=[a,b], o operador linear do espaço dada pela matriz

> MT := v -> matrix(3,3, [1,0,v[1], 0,1,v[2],0,0,1]);

> MT([a,b]);

> evalm(MT([a,b])&* [x,y,1]); No plano z=1, o efeito é a translação segundo o vetor v=[a,b]:

Assim, podemos construir a aplicação translação do plano:

> tau2 := proc(v,P)

> local P1, Q1, MT1, Q;

> P1 := [P[1],P[2],1]:

> MT1 := matrix(3,3, [1,0,v[1], 0,1,v[2],0,0,1]):

> Q1 := evalm(MT1&*P1):

> Q :=[Q1[1],Q1[2]]:

> return(Q):

> end proc:

> tau2([a,b],[x,y]);

> tau3 := proc(v,P1)

> local Q1, MT1;

> MT1 := matrix(3,3, [1,0,v[1], 0,1,v[2],0,0,1]):

> Q1 := convert(evalm(MT1&*P1),list):

> return(Q1):

> end proc: Mantendo o formato de 3 coordenadas, para composição com outros movimentos.

> tau3([a,b], [x,y,1]);

> figura1[0] := map( proc(P) [P[1],P[2],1]; end proc, figura[0]);

> plotfigura1[0]:= polygonplot3d(figura1[0], color=yellow):

> plotfigura[20] := polygonplot(map2(tau2,[1,1],figura[0]),color=green):

> plotfigura1[20] := polygonplot3d(map2(tau3,[1,1],figura1[0]),color=green):

> display({plotfigura[0], plotfigura[20]}, scaling=constrained);

> display({plotfigura1[0], plotfigura1[20]}, scaling=constrained, axes=boxed,view=0..1);

>

7. Rotações no plano e os operadores lineares do espaço

As rotações no plano em torno da origem já são operadores lineares no plano.

Mas ele pode ser estendido a um operador linear do espaço que efetua a rotação desejada no plano z=1.

Assim, compondo com translações, pode-se obter também as rotações do plano em torno de pontos fora da origem utilizando operadores lineares no espaço.

> MRo := theta -> matrix(3,3, [cos(theta), -sin(theta),0, sin(theta), cos(theta),0,0,0,1]);

> MRo(Pi/3);

> evalm(MRo(theta)&*[x,y,1]);

> Ro2 := proc(t,P)

> local P1, M1, Q1,Q;

> P1 := [P[1],P[2],1]:

> M1 := matrix(3,3, [cos(t), -sin(t),0, sin(t), cos(t),0,0,0,1]):

> Q1 := evalm(M1 &* P1):

> Q := [Q1[1], Q1[2]]:

> return(Q):

> end proc:

> Ro2(Pi/3,[x,y]);

> figura[20]:=map2(Ro2, Pi/3, figura[0]);

> Ro3 := proc(t,P1)

> local M1,Q1;

> M1 := matrix(3,3, [cos(t), -sin(t),0, sin(t), cos(t),0,0,0,1]):

> Q1 := convert(evalm(M1 &* P1),list):

> return(Q1):

> end proc:

> Ro3(Pi/3, [x,y,1]);

> figura1[20]:=map2(Ro3,Pi/3,figura1[0]);

> plotfigura1[0]:= polygonplot3d(figura1[0], color=yellow):

> plotfigura[20] := polygonplot(figura[20],color=green):

> plotfigura1[20] := polygonplot3d(figura1[20],color=green):

> display({plotfigura[0], plotfigura[20]}, scaling=constrained);

> display({plotfigura1[0], plotfigura1[20]}, scaling=constrained, axes=boxed, view=0..1);

> C :=[3,2]: centro de rotação dada de forma global

> RoC3 := proc(tC,P1)

> local t,C,M1,MT1,Q1;

> t := tC[1]:

> C := tC[2]:

> M1 := matrix(3,3, [cos(t), -sin(t),0, sin(t), cos(t),0,0,0,1]):

> MT1 := v -> matrix(3,3,[1,0,v[1],0,1,v[2],0,0,1]):

> Q1 := convert(evalm(MT1(C) &* M1 &* MT1(-C)&* P1),list):

> return(Q1):

> end proc:

> map2(RoC3,[theta,C],figura1[0]);

> RoC2 :=proc(tC,P)

> local P1, Q1, Q;

> P1 := [op(P),1]:

> Q1 := RoC3(tC,P1):

> Q := [Q1[1],Q1[2]]:

> return(Q):

> end proc:

> map2(RoC2,[theta,C],figura[0]);

> animaRoC2 := proc(C,tmax,pol, N, cor)

> local C1, fig0, i, t, fig1, quadro;

> fig0 := pointplot(C,color=red):

> for i from 0 to N do

> t := (i/N)*tmax:

> fig1:=polygonplot(map2(RoC2,[t,C],pol),color=cor):

> quadro[i]:=display({fig0,fig1}):

> od:

> display([seq(quadro[i],i=0..N)], insequence=true, scaling=constrained);

> end proc:

> animaRoC2([3,1],2*Pi,figura[0],20,green);

> animaRoC3 := proc(C,tmax,pol1, N, cor)

> local C1, fig0, i, t, fig1, quadro;

> fig0 := pointplot3d([op(C),1],color=red):

> for i from 0 to N do

> t := (i/N)*tmax:

> fig1:=polygonplot3d(map2(RoC3,[t,C],pol1),color=cor, axes=boxed,view=0..1):

> quadro[i]:=display({fig0,fig1}):

> od:

> display([seq(quadro[i],i=0..N)], insequence=true, scaling=constrained);

> end proc:

> animaRoC3([3,1],2*Pi,figura1[0],20,green);

>

8. Reflexões no plano e os operadores lineares do espaço

Analogamente com o caso das rotações, podemos obter tanto as reflexões segundo retas pela origem (que já são lineares no plano) quanto as reflexões segundo retas fora da origem, usando coordenadas homogêneas.

Vamos tratar aqui somente de reflexões segundo retas dadas por dois pontos A e B.

> Re2 := proc(AB,P)

> local A1, B1, P1, Q1, Q, v, v1, M1, T1, R1;

> A1 := AB[1]: B1 := AB[2]: P1 := [P[1],P[2],1]:

> v := evalm(AB[2]-AB[1]): v1:= evalm(v/norm(v,2)):

> T1 := (a,b) -> matrix(3,3,[1,0,a,0,1,b,0,0,1]):

> M1 := v1 -> matrix(3,3,[v1[1],-v1[2],0,v1[2],v1[1],0,0,0,1]):

> R1 := v1 -> evalm(M1(v1)&*matrix(3,3,[1,0,0,0,-1,0,0,0,1])&*transpose(M1(v1))):

> Q1 := evalm( T1(A1[1],A1[2])&* R1(v1) &* T1(-A1[1],-A1[2]) &*P1 ):

> Q := [Q1[1],Q1[2]]:

> return(Q):

> end proc:

> Re2([[1,0],[0,1]],[x,y]);

> figura[20]:=map2(Re2,[[1,0],[0,1]], figura[0]);

> plotfigura[20] := polygonplot(figura[20], color=green):

> display({plotfigura[0], plotfigura[20], plot([[1,0],[0,1]],color=red,thickness=3)}, scaling=constrained);

> anima2 := proc(A,B,pol,N,cor)

> local AB, pol1,reta, i, t, quadro;

> AB := [A,B]: reta:= plot(AB, color=red, thickness=3):

> pol1 := map2(Re2,AB,pol):

> for i from 0 to N do

> t := i/N:

> quadro[i]:=display({polygonplot(evalm((1-t)*pol +t*pol1), color=cor), reta}):

> od:

> display([ seq(quadro[i], i=0..N)], insequence=true, scaling=constrained);

> end proc:

> anima2([1,0],[0,1],figura[0],20,green);

>

Exercícios

1. Escreva a matriz 3x3 da translação do plano segundo o vetor v = [a,b], em coordenadas homogêneas. Como essa matriz é usada na translação?

Solução: M = . Essa matriz é usada do seguinte modo: para cada (x,y) do plano, é feita a operação x e depois, desprezada a última coordenada z=1 do resultado. Como a multiplicação fornece (x+a, y+b, 1), a translação assim obtida leva (x,y) em (x+a, y+b).

2. Escreva a matriz 3x3 da rotação de ângulo do plano em torno da origem, em coordenadas homogêneas.

Ídem, em torno do ponto C=[a,b].

Obtenha, utilizando as matrizes acima, a rotação do ponto P = [10,0] em torno da origem e em torno de C=[3,2].

3. Escreva a matriz 3x3 da relfexão do plano em relação à reta por A = [1,0] e B = [0,-1] e obtenha o resultado da reflexão aplicada ao ponto P = (x,y).

4. Quais dos movimentos rígidos descritos acima são transformações lineares do plano no plano (operadores lineares do plano)?