Bases mathématiques du graphisme à 2 dimensions

Dernière édition par papydall le Sam 30 Mar 2013 - 17:07, édité 1 fois

Bases mathématiques du graphisme à 2 dimensions

1-La fenêtre (WINDOW)
(Rien à voir avec le système d’exploitation Windows)
L’espace à 2 dimensions de l’utilisateur s’étend théoriquement à l’infini. Mais en pratique, personne ne travaille avec un espace aussi grand !
D’une manière générale, on s’intéresse à une portion rectangulaire de cet espace.
Cette zone peut être considérée comme une fenêtre qui spécifie la zone de données qui doit être vue par l’ordinateur.
Les quatre variables W1, W2, W3, W4 qui définissent la fenêtre sont données dans les unités de l’utilisateur.
Elles peuvent être des kilomètres, des heures, des volts, des Euros, etc.
W1 = abscisse minimum ; W2 = abscisse maximum ; W3 = ordonnée minimum ; W4 = ordonnée maximum

2- La clôture (VIEWPORT)
C’est la zone rectangulaire de l’écran sur laquelle sera projeté le contenu de la fenêtre.
Les quatre variables V1, V2, V3, V4 sont, cette fois, données dans les unités du système graphique.

3-Passage des coordonnées utilisateur aux coordonnées écran
Voici les formules (sans démonstration)

XE = (XR * (V2 – V1) – W1 * V2 + V1 * W2) / (W2 –W3)
YE = (YR * (V4 - V3) – W3 * V4 + V3 * W4) / (W4 – W3)
Avec
XE et YE : coordonnées écran
XR et YR : coordonnées réelles du point dans l’univers de l’utilisateur
V1, V2,V3,V4 : coordonnées de la clôture (VIEWPORT)
W1, W2, W3, W4 : coordonnées de la fenêtre (WINDOW)

4- Les transformations du plan
Les principales transformations du plan sont : les translations, les changements d’échelles, les symétries, les rotations et les cisaillements.
Le calcul matriciel permet de résoudre tous ces problèmes avec aisance.
La théorie des matrices est assez ardue et ne sera pas développée ici.
Je vous donne juste les formules à utiliser dans vos programmes en évitant les maux de tête ! (On n’a pas tous un stock de doliprane !)
Mais un soupçon de théorie s’avère nécessaire.
Soit (x,y) la coordonnée d’un point du plan cartésien (merci René Descartes).
On considère cette coordonnée comme une matrice de une ligne sur deux colonnes et qu’on note matrice 1X2 (lire matrice 1 croix 2)
La matrice générale M =

A B
C D

est une matrice de 2 lignes sur 2 colonnes et sera notée matrice 2X2

Mathématiquement on peut définir le produit matriciel suivant :
(x’ y’) = (x y) * M = (A*x+c*y B*x+D*y)

Tout point du plan(x,y) multiplié par la matrice (2X2) a pour transformé un nouveau point du plan (x’,y’) tel que :
x’ = A*x+C*y
y’ = B*x+D*y

La transformation obtenue dépendra des valeurs données aux variables A,B,C,D

Les changement d’échelles
Ces transformations sont contrôlées par la matrice
A 0
0 D
Le terme A donne un agrandissement ou un rapetissement suivant l’axe des X.
Le terme D donne un agrandissement ou un rapetissement suivant l’axe des Y.
Remarque :
La multiplication par la matrice unité transforme tout point en lui-même.
La matrice unité est de la forme
1 0
0 1

Les symétries
Les matrices contrôlant les symétries sont des cas particuliers de la matrice changement d’échelle dans laquelle A et/ou D sont négatifs
-1 0
0 1
produira une symétrie par rapport à l’axe des Y
1 0
0 -1
produira une symétrie par rapport à l’axe des X
-1 0
0 -1
produira une symétrie par rapport aux 2 axes c.a.d une symétrie centrale par rapport à l’origine

Les cisaillements
La matrice
1 B
0 1
produira un cisaillement en Y.
La matrice
1 0
C 1
donnera un cisaillement en X.
La matrice
1 B
C 1
donnera un cisaillement dans les deux directions

Les rotations
La matrice générale d’une rotation est :
cos(theta) sin(theta)
-sin(theta) cos(theta)
avec theta l’angle de rotation ( positif ou négatif)

Les translations
Bien que les translations soient des transformations du plan très élémentaires, la structure générale d’une matrice (2X2) ne permet pas de les réaliser.
Pour lever cette difficulté, on doit introduire ce qu’on appelle les coordonnées homogènes.
Ça sera l’objet du prochain sujet.

Après la théorie, passons à la pratique

Le code suivant montre les effets de la matrice 2X2

Code:: ' ******************************************************************************
' Les transformations du plan : les effets de la matrice 2X2
' Matrice2X2.bas
' par Papydall
' ******************************************************************************
Run()
end
' ******************************************************************************
SUB Run()
caption 0,"Les transformations du plan"
Declarer_Variables(): Init_Figure() : Saisie_Matrice_Transformation()
Recherche_Fenetre_Provisoire() : Viewport() : go()
END_SUB
' ******************************************************************************
SUB Declarer_Variables()
dim n : n = 4 : ' Nombre des sommets de la figure étudiée, ici c'est un carré
dim xp(n+1),yp(n+1) : ' Coordonnées des sommets de la figure étudiée
dim A,B,C,D : ' Termes de la matrice de transformation
dim w1,w2,w3,w4 : ' Coordonnées de la fenêtre (window)données dans les unités de l'utilisateur
' w1 = abscisse mini; w2 = abscisse maxi; w3 = ordonnée mini; w4 = ordonnée maxi
' La fenêtre spécifie la zone de données qui doit être vue par l'ordinateur
dim v1,v2,v3,v4 : ' Coordonnées de la clôture (Viewport) données dans les unités du système graphique
' Cela signifie que la clôture dépend essentiellement de l'ordinateur.
' La clôture spécifie la zone de l'écran où sera projeté le contenu de la fenêtre
dim a8,a9,b8,b9,u8,v8,t8,t9,q9,p9,x6,y6,x5,y5 : ' variables de travail
END_SUB
' ******************************************************************************
' Initialisation de la figure de départ
SUB Init_Figure()
dim_local i
for i = 1 to n : read xp(i) : read yp(i) : next i
xp(n+1) = xp(1) : yp(n+1) = yp(1)
' Utilisez l'une ou l'autre ligne de DATA et pas les deux à la fois !!!!
data 1,1,2,1,2,2,1,2
' data 0,0,1,0,1,1,0,1 : ' l'un des sommets du carré est à l'origine
END_SUB
' ******************************************************************************
' Saisie des termes de la matrice de transformation
' La matrice est de la forme:
' A B
' C D
' La transformation obtenue dépend des valeurs données aux variables A,B,C,D

' 1) Les changements d'échelles sont contrôlés par la matrice :
' A 0
' 0 D
' exemple : pour A,B,C,D, entrez 3, 0, 0, 1 ; ou 1, 0, 0, 0.2 ; ou 4, 0, 4, 0

' 2) Les matrices qui contrôlent les symétries ne sont que des cas particuliers
' de la matrice changement d'échelle dans laquelle A et/ou D sont négatifs.
' exemple : pour A,B,C,D, entrez les valeurs
' -1, 0, 0, 1 ===> symétrie par rapport à l'axe des Y
' 1, 0, 0, -1 ===> symétrie par rapport à l'axe des X
' -1, 0, 0, -1 ===> symétrie par rapport aux 2 axes c.a.d une symétrie centrale par rapport à l'origine

' 3) Les cisaillements:
' exemple : pour A,B,C,D, entrez les valeurs
' 1, 2, 0, 1 ===> cisaillement en Y
' 1, 0, 2, 1 ===> cisaillement en X
' 1, 2, 3, 1 ===> cisaillement dans les 2 directions

' 4) Les rotations autour de l'origine sont contrôlées par la matrice :
' COS(Theta) SIN(Theta)
' -SIN(Theta) COS(Theta)
' avec Theta angle de rotation en radians
' exemple : pour A, B, C, D entrez les valeurs
' 0.866, 0.5, -0.5, 0.866 ===> rotation de +(pi/6) c.a.d 30°
' ------------------------------------------------------------------------------
SUB Saisie_Matrice_Transformation()
dim_local rep$
repeat
rep$ = message_input$("Terme de la matrice de transformation","A =","")
until numeric(rep$) > 0
A = val(rep$)
repeat
rep$ = message_input$("Terme de la matrice de transformation","B =","")
until numeric(rep$) > 0
B = val(rep$)
repeat
rep$ = message_input$("Terme de la matrice de transformation","C =","")
until numeric(rep$) > 0
C = val(rep$)
repeat
rep$ = message_input$("Terme de la matrice de transformation","D =","")
until numeric(rep$) > 0
D = val(rep$)
END_SUB
' ******************************************************************************
' recherche de la fenêtre provisoire
SUB Recherche_Fenetre_Provisoire()
dim_local i, m,x1,y1
w1 = power(10,20) : w2 = 0-power(10,20)
w3 = power(10,20) : w4 = 0-power(10,20)
' On applique la transformation à tous les points de l'objet afin de déterminer
' les abscisses et les ordonnées extremum qui nous fournirons la fenêtre w1,w2,w3,w4
for i = 1 to n
x1 = xp(i) : y1 = yp(i) : Recherche_Fenetre(x1,y1)
x1 = a*xp(i)+c*yp(i) : y1 = b*xp(i)+d*yp(i) : Recherche_Fenetre(x1,y1)
next i
' M contient le maximum des w, il sert à obtenir une fenêtre carrée et une base orthonormée
m = abs(w1)
if m < abs(w2) then m = abs(w2)
if m < abs(w3) then m = abs(w3)
if m < abs(w4) then m = abs(w4)
w1 = 0-m : w2 = m : w3 = 0-m : w4 = m
END_SUB
' ******************************************************************************
' Initialiser la clôture
SUB Viewport()
read v1 : read v2 : read v3 : read v4
data 100,350,100,350 : ' choix d'une clôture carrée afin d'éviter les distorsions
END_SUB
' ******************************************************************************
' La variable w$ peut prendre l'une de 2 valeurs "U" pour UP ou "D" pour DOWN
' si W$ = "U", on se déplace plume levée (sans laisser de trace) c.a.d 2D_POLY_FROM
' Si w$ = "D", on se deplace plume baissée ( en dessinant le trait) c.a.d 2D_POLY_TO
SUB Go()
dim_local x,y,w$,i
' Tracer et graduer les axes de 1 en 1
Coord_Ecran() : Tracer_Axes() : Graduer_Axes(1,1)
' Tracer la figure initiale
x = xp(1) : y = yp(1) : w$ = "U" : Projection(x,y,w$) : w$ = "D"
for i = 2 to n+1 : x = xp(i) : y = yp(i) : Projection(x,y,w$) : next i
' Tracer la figure transformée
2d_pen_color 255,0,0 : x = a*xp(1)+c*yp(1) : y = b*xp(1)+d*yp(1)
w$ = "U" : Projection(x,y,w$) : w$ = "D"
for i = 2 to n+1
x = a*xp(i)+c*yp(i) : y = b*xp(i)+d*yp(i) :Projection(x,y,w$)
next i
Affiche() : ' Afficher la matrice de transformation
END_SUB
' ******************************************************************************
' recherche fenêtre
SUB Recherche_Fenetre(x1,y1)
if x1 < w1 then w1 = x1
if x1 > w2 then w2 = x1
if y1 < w3 then w3 = y1
if y1 > w4 then w4 = y1
END_SUB
' ******************************************************************************
' Formules de passage des coordonnées utilisateur aux coordonnées écran
SUB Coord_Ecran()
a8 = (v2-v1)/(w2-w1) : b8 = (v1*w2-v2*w1)/(w2-w1)
a9 = (v4-v3)/(w4-w3) : b9 = (v3*w4-v4*w3)/(w4-w3)
END_SUB
' ******************************************************************************
' graduation des axes de 1 en 1
SUB Graduer_Axes(u,v)
dim_local w$
t8 = 0.02 * (w2-w1) : t9 = 0.02*(w4-w3)
u8 = ((p9-w1)/u - int((p9-w1)/u))*u : v8 = ((q9-w3)/v - int((q9-w3)/v))*v
for x6 = w1+u8 to w2 step u
y6 = q9 : w$ = "U" : Tracer(w$) : y6 = q9+t9 : w$ = "D" : Tracer(w$)
next x6
for y6 = w3+v8 to w4 step v
x6 = p9 : w$ = "U" : Tracer(w$) : x6 = p9 + t8 : w$ = "D" : Tracer(w$)
next y6

END_SUB
' ******************************************************************************
' projection + tracer
SUB Projection(x,y,w$)
x6 = x : y6 = y : Tracer(w$)
END_SUB
' ******************************************************************************
' tracé des axes
SUB Tracer_Axes()
dim_local w$
p9 = w1 : q9 = w3
if w1 < 0 and w2 > 0 then p9 = 0
if w3 < 0 and w4 > 0 then q9 = 0
x6 = w1 : y6 = q9 : w$ = "U" : Tracer(w$)
x6 = w2 : w$ = "D" : Tracer(w$)
x6 = p9 : y6 = w3 : w$ = "U" : Tracer(w$)
y6 = w4 : w$ = "D" : Tracer(w$)
END_SUB
' ******************************************************************************
SUB Tracer(w$)
x5 = a8*x6+b8
y5 = 400 - (a9*y6+b9)
if w$ = "U" then 2d_poly_from x5,y5 : exit_sub
2d_poly_to x5,y5
END_SUB
' ******************************************************************************
SUB Affiche()
print : print : print " MATRICE DE TRANSFORMATION" : print
print " A = ";A;" ";"B = ";B
print " C = ";C;" ";"D = ";D
END_SUB
' ******************************************************************************

Si mon charabia peut servir à quelqu’un je serais content !
EDIT
Toutes mes excuses pour la mise en page!

Sujet: re Sam 30 Mar 2013 - 3:10

Heu.....Je vais troquer mes Dolipranes pour des exomils...

lol!

Plaisanterie mise à part, Belle exposé, même si il va me falloir un peu de temps pour tout assimiler... Laughing

Le calcul matriciel est un puissant outil.
On peut toujours utiliser les formules sans se soucier de leur provenance.
De cette façon on ménage Doliprane et lexomil !

mathématiques - Bases mathématiques du graphisme à 2 dimensions Perdu-cherche-carte

mathématiques - Bases mathématiques du graphisme à 2 dimensions Perdu-cherche-carte

Bonjour Papydall, Smile

Super cette démonstration! Et je sais exactement quoi faire de tes formules. Un vieux programme rangé aux oubliettes depuis belle lurette...
J'attend la suite avec impatience... cheers

A+

Bel exposé / démonstration Smile

Dernière édition par papydall le Dim 31 Mar 2013 - 5:05, édité 2 fois

Salut tout le monde.

Voici la suite promise.

Les translations
Le translaté de tout point (x,y) du plan a la forme :
x’ = x + M
y’ = y + N
Or aucun produit par la matrice générale (2X2) ne permet de trouver ces relations.
Que pouvons-nous faire alors ? Certainement ne pas baisser les bras !

Nous allons introduire une troisième composante aux vecteurs (x y) et (x’ y’) pour devenir (x y 1) et (x’ y’ 1).
La matrice de transformation doit alors obligatoirement devenir une matrice (3X2) car
un produit matriciel n’est possible que si le nombre de lignes de la deuxième matrice égale le nombre de colonnes de la première
Soit la nouvelle matrice de transformation :
1 0
0 1
M N
Dans ces conditions, le produit matriciel nous donne :
x’ = x + M
y’ = y + N
Le coefficient M provoque une translation par rapport à l’axe X et le coefficient N provoque une translation par rapport à l’axe Y.
On a l’impression d’avoir résolu le problème des translations, mais une autre difficulté apparait.
La matrice (3X2) n’étant pas carrée ne possède pas d’inverse !!!
Or on a besoin de l’inversion matricielle.
Qu’à cela ne tienne ! La théorie des matrices nous vient au secours !
Nous pouvons rajouter une troisième colonne à la matrice (3X2) de façon à obtenir une matrice carrée (3X3).
1 0 0
0 1 0
M N 1
Cette fois-ci, le produit matriciel nous donne :
(x+M y+N 1) = (x’ y’ 1)
La représentation de la position d’un point du plan par un vecteur à trois dimensions est une représentation en coordonnées homogènes.

Retenons
Tout point du plan à distance finie de coordonnée (x,y) a pour coordonnée homogène le triple (x,y,1) ou encore n’importe quel triple de 3 nombres proportionnels (kx,ky,k) où k est un réel non nul.
Donc x’ = kx ; y’ = ky ; z’ = k
On en déduit que x = x’/k et y = y’/k
Ce sont les formules de passage des coordonnées homogènes aux coordonnés cartésiennes.

Composition de transformations
Toutes les transformations données jusqu’ici sont centrées à l’origine des axes : le point (0,0) est donc un invariant.
Après avoir vu les translations, nous sommes en mesure de résoudre le problème suivant :
Quelle est la matrice de la transformation qui fait tourner une figure (une petite fusée par exemple) autour d’un point donné (x,y) d’un angle theta donné ?

Les coordonnées homogènes vont nous simplifier la vie.
Tout d’abord, nous allons transformer toutes les matrices (2X2) en matrices (3X3).
La matrice générale
A B
C D
devient
A B 0
C D 0
0 0 1
Une rotation autour d’un point arbitraire du plan sera accomplie en faisant :
1- une translation du centre de rotation à l’origine des axes
2- la rotation désirée
3- une translation du résultat au centre de rotation initial

REMARQUE
L’ordre des opérations a beaucoup d’importance car en général le produit matriciel n’est pas commutatif.

Il est avantageux d’effectuer en une seule fois ces trois opérations.
On obtient (sans entrer dans le détails du calcul, somme toute, assez pénible), les formules suivantes :

x’ = x*cos(theta) – y*sin(theta) – M*cos(theta) + N*sin(theta) + M
y’ = x*sin(theta) + y*cos(theta) – M*sin(theta) –N*cos(theta) + N

En pratique, il suffit de lire la coordonnée (M,N) du centre de rotation quelconque et la valeur de l’angle de rotation theta , ensuite on applique ces deux formules à tous les points de l’objet considéré.

Et pour conclure
La matrice générale (3X3) utilisée avec les coordonnées homogènes dans le plan est de la forme :
A B 1
C D 1
M N E
Cette matrice peut être divisée en 4 parties qui ont chacune un rôle bien précis :
• Les termes A,B,C,D produisent les changements d’échelles, les rotations et les cisaillement.
• Les termes M et N produisent les translations.
• Le terme E produit un changement d’échelle général, c.a.d uniforme selon les deux axes.
En effet la coordonnée cartésienne (x’,y’) s’obtient en faisant : x’ = x/E et y’ = y/E
Si E > 1 on a un rapetissement
Si E < 1 on a un agrandissement

Dans le programme qui sera donné en exemple, on prendra E =1 et nous donnerons à A et D les valeurs convenables pour le changement d’échelle souhaité.
Si A <> D on aura un changement d’échelle différent selon les deux axes.
Si A = D le changement sera uniforme.

Remarque
D’une manière générale, la multiplication de deux matrices n’est pas commutative.
Mais, il y a commutativité dans les cas suivants :
• translation X translation
• changement d’échelle X changement d’échelle
• rotation X rotation
• changement d’échelle uniforme X rotation

Après la théorie, la pratique

Le programme suivant autorise les translations dans le plan.
On considère (à titre d’exemple) une petite fusée sur laquelle on peut effectuer toute sorte de transformation.
En effet pour transformer une figure, il suffit de transformer tous les points de cette figure.
Pour tout point du plan de coordonnée (x,y), on aura, après transformation, la coordonnée (x’,y’) :

x’ = A*x + C*y + M
y’ = B*x + D*y + N

NB : Je reconnais que je suis le plus mauvais "dessinateur" que l’humanité ait connu.
Alors, si « ma fusée » ne vous convient pas, laissez libre cours à votre imagination pour dessiner un plus bel objet.
Pour cela, vous pouvez dessiner votre objet sur une feuille quadrillée et relever les coordonnées (x,y) de tous les points en les mettant dans la ligne 34 : DATA ...

Code:: ' ******************************************************************************
' Les transformations du plan : les effets de la matrice 3X3
' Matrice3X3.bas
' par Papydall
' ******************************************************************************
Run()
end
' ******************************************************************************
SUB Run()
caption 0,"Les transformations du plan : les effets de la matrice 3X3"
Declarer_Variables(): Init_Figure() : Saisie_Matrice_Transformation()
Recherche_Fenetre_Provisoire() : Viewport() : go()
END_SUB
' ******************************************************************************
SUB Declarer_Variables()
dim s : s = 11 : ' Nombre des sommets de la figure étudiée, ici c'est une petite fusée !
dim xp(s+1),yp(s+1) : ' Coordonnées des sommets de la figure étudiée
dim A,B,C,D,M,N : ' Termes de la matrice de transformation
dim w1,w2,w3,w4 : ' Coordonnées de la fenêtre (window)données dans les unités de l'utilisateur
' w1 = abscisse mini; w2 = abscisse maxi; w3 = ordonnée mini; w4 = ordonnée maxi
' La fenêtre spécifie la zone de données qui doit être vue par l'ordinateur
dim v1,v2,v3,v4 : ' Coordonnées de la clôture (Viewport) données dans les unités du système graphique
' Cela signifie que la clôture dépend essentiellement de l'ordinateur.
' La clôture spécifie la zone de l'écran où sera projeté le contenu de la fenêtre
dim a8,a9,b8,b9,u8,v8,t8,t9,q9,p9,x6,y6,x5,y5 : ' variables de travail
END_SUB
' ******************************************************************************
' Initialisation de la figure de départ
SUB Init_Figure()
dim_local i
for i = 1 to s : read xp(i) : read yp(i) : next i
xp(s+1) = xp(1) : yp(s+1) = yp(1)
' Coordonnées de notre fusée
data 5,7,4,6,4,5,3,4,4,4,4,3,6,3,6,4,7,4,6,5,6,6
END_SUB
' ******************************************************************************
' Saisie des termes de la matrice de transformation
' La matrice est de la forme:
' A B 1
' C D 1
' M N E
' La transformation obtenue dépend des valeurs données aux variables A,B,C,D,M,N,E

' Les termes A,B,C,D (voir le programme Matrice2X2.bas) produisent les changements
' d'échelles, les rotations et les cisaillements.
' Les termes M et N produisent les translations.
' Le terme E produit un changement d'échelle général, c.à.d. uniforme selon les 2 axes.
' Si E > 1 on a un rapetissement
' Si E < 1 on a un agrandissement
' REMARQUE :
' dans ce programme, on prend E = 1, et on donnera à A et D les valeurs convenales
' pour le changement d'échelle souhaité :
' Si A <> D on aura un changement d'échelle différent selon les deux axes.
' Si A = D le changement sera uniforme.

' ------------------------------------------------------------------------------
SUB Saisie_Matrice_Transformation()
dim_local rep$
repeat
rep$ = message_input$("Terme de la matrice de transformation","A =","")
until numeric(rep$) > 0
A = val(rep$)
repeat
rep$ = message_input$("Terme de la matrice de transformation","B =","")
until numeric(rep$) > 0
B = val(rep$)
repeat
rep$ = message_input$("Terme de la matrice de transformation","C =","")
until numeric(rep$) > 0
C = val(rep$)
repeat
rep$ = message_input$("Terme de la matrice de transformation","D =","")
until numeric(rep$) > 0
D = val(rep$)
repeat
rep$ = message_input$("Terme de la matrice de transformation","M =","")
until numeric(rep$) > 0
M = val(rep$)
repeat
rep$ = message_input$("Terme de la matrice de transformation","N =","")
until numeric(rep$) > 0
N = val(rep$)

END_SUB
' ******************************************************************************
' recherche de la fenêtre provisoire
SUB Recherche_Fenetre_Provisoire()
dim_local i, m1,x1,y1
w1 = power(10,20) : w2 = 0-power(10,20)
w3 = power(10,20) : w4 = 0-power(10,20)
' On applique la transformation à tous les points de l'objet afin de déterminer
' les abscisses et les ordonnées extremum qui nous fournirons la fenêtre w1,w2,w3,w4
for i = 1 to s
x1 = xp(i) : y1 = yp(i) : Recherche_Fenetre(x1,y1)
x1 = a*xp(i)+c*yp(i)+M : y1 = b*xp(i)+d*yp(i)+N : Recherche_Fenetre(x1,y1)
next i
' M1 contient le maximum des w, il sert à obtenir une fenêtre carrée et une base orthonormée
m1 = abs(w1)
if m1 < abs(w2) then m1 = abs(w2)
if m1 < abs(w3) then m1 = abs(w3)
if m1 < abs(w4) then m1 = abs(w4)
w1 = 0-m1 : w2 = m1 : w3 = 0-m1 : w4 = m1
END_SUB
' ******************************************************************************
' Initialiser la clôture
SUB Viewport()
read v1 : read v2 : read v3 : read v4
data 100,350,100,350 : ' choix d'une clôture carrée afin d'éviter les distorsions
END_SUB
' ******************************************************************************
' La variable w$ peut prendre l'une de 2 valeurs "U" pour UP ou "D" pour DOWN
' si W$ = "U", on se déplace plume levée (sans laisser de trace) c.à.d 2D_POLY_FROM
' Si w$ = "D", on se deplace plume baissée (en dessinant le trait) c.à.d 2D_POLY_TO
SUB Go()
dim_local x,y,w$,i
' Tracer et graduer les axes de 1 en 1
Coord_Ecran() : Tracer_Axes() : Graduer_Axes(1,1)
' Tracer la figure donnée
x = xp(1) : y = yp(1) : w$ = "U" : Projection(x,y,w$) : w$ = "D"
for i = 2 to s+1 : x = xp(i) : y = yp(i) : Projection(x,y,w$) : next i
' Tracer la figure transformée
2d_pen_color 255,0,0 : x = a*xp(1)+c*yp(1)+M : y = b*xp(1)+d*yp(1)+N
w$ = "U" : Projection(x,y,w$) : w$ = "D"
for i = 2 to s+1
x = a*xp(i)+c*yp(i)+M : y = b*xp(i)+d*yp(i)+N :Projection(x,y,w$)
next i
Affiche() : ' Afficher la matrice de transformation
END_SUB
' ******************************************************************************
' recherche fenêtre
SUB Recherche_Fenetre(x1,y1)
if x1 < w1 then w1 = x1
if x1 > w2 then w2 = x1
if y1 < w3 then w3 = y1
if y1 > w4 then w4 = y1
END_SUB
' ******************************************************************************
' Formules de passage des coordonnées utilisateur aux coordonnées écran
SUB Coord_Ecran()
a8 = (v2-v1)/(w2-w1) : b8 = (v1*w2-v2*w1)/(w2-w1)
a9 = (v4-v3)/(w4-w3) : b9 = (v3*w4-v4*w3)/(w4-w3)
END_SUB
' ******************************************************************************
' graduation des axes de 1 en 1
SUB Graduer_Axes(u,v)
dim_local w$
t8 = 0.02 * (w2-w1) : t9 = 0.02*(w4-w3)
u8 = ((p9-w1)/u - int((p9-w1)/u))*u : v8 = ((q9-w3)/v - int((q9-w3)/v))*v
for x6 = w1+u8 to w2 step u
y6 = q9 : w$ = "U" : Tracer(w$) : y6 = q9+t9 : w$ = "D" : Tracer(w$)
next x6
for y6 = w3+v8 to w4 step v
x6 = p9 : w$ = "U" : Tracer(w$) : x6 = p9 + t8 : w$ = "D" : Tracer(w$)
next y6

END_SUB
' ******************************************************************************
' projection + tracer
SUB Projection(x,y,w$)
x6 = x : y6 = y : Tracer(w$)
END_SUB
' ******************************************************************************
' tracé des axes
SUB Tracer_Axes()
dim_local w$
p9 = w1 : q9 = w3
if w1 < 0 and w2 > 0 then p9 = 0
if w3 < 0 and w4 > 0 then q9 = 0
x6 = w1 : y6 = q9 : w$ = "U" : Tracer(w$)
x6 = w2 : w$ = "D" : Tracer(w$)
x6 = p9 : y6 = w3 : w$ = "U" : Tracer(w$)
y6 = w4 : w$ = "D" : Tracer(w$)
END_SUB
' ******************************************************************************
SUB Tracer(w$)
x5 = a8*x6+b8
y5 = 400 - (a9*y6+b9)
if w$ = "U" then 2d_poly_from x5,y5 : exit_sub
2d_poly_to x5,y5
END_SUB
' ******************************************************************************
SUB Affiche()
print : print : print " MATRICE DE TRANSFORMATION" : print
print " A = ";A;" ";"B = ";B
print " C = ";C;" ";"D = ";D
print " M = ";M;" ";"N = ";N
END_SUB
' ******************************************************************************

A SUIVRE ….

Remarquable de clarté !

EDIT

Si j'osais... Ces calculs de matrices sont bien adaptables à un environnement en 3 dimensions ? Pour l'appliquer dans un SCENE3D. Cela donnerait sûrement une matrice 4x4, par extension du modèle de la matrice 3x3 pour un espace en 2 dimensions ?

Nombre de messages : 812 Localisation : Troyes Date d'inscription : 05/02/2011

bravo papydall et merci pour le cour de mathématique

Klaus a écrit:: Remarquable de clarté !

EDIT

Si j'osais... Ces calculs de matrices sont bien adaptables à un environnement en 3 dimensions ? Pour l'appliquer dans un SCENE3D. Cela donnerait sûrement une matrice 4x4, par extension du modèle de la matrice 3x3 pour un espace en 2 dimensions ?

Parfaitement exact !
Dans mon dernier post, j’ai écris A suivre ...
Mais, moi je ne suis pas aussi rapide que Klaus !
Il me faut un peu de temps et il me manque terriblement à ce moment.
Une chose est sûre : Les bases mathématiques du graphisme à 3 dimensions suivront...

Super ! De plus en plus intéressant !

Papydall,
je suis sidéré, époustouflé, etc...
et impatient de voir la suite! bounce

les calculs en 3 dimensionns, ça me donne déjà des idées.... Idea

J"en reste pantois !

Maintenant il me reste à comprendre.

Bravo cheers

Salut tout le monde et mille mercis pour vos réactions.

Les 2 programmes précédents n’étaient pas agréables à manipuler.
Il fallait entrer la valeur des termes A,B,C,D,M,N.
Dans le cas d’une rotation, il fallait calculer au préalable les nombres trigonométriques qui intervenaient dans les termes A,B,C,D et aussi avoir effectué le produit de 3 matrices afin de connaître les termes de la matrice résultante.

Le programme suivant autorise plusieurs options très facilement :
• Transformations par rapport à l’origine des axes
1- Rotation
2- Changement d’échelles
3- Symétrie
4- Cisaillement

• Transformations par rapport à un point quelconque :
On entre les coordonnées (M,N) de ce point, puis on a le choix entre :
1- Rotation
2- Homothétie
3- Symétrie

Conclusion : Les 3 programmes postés ne sont pas une fin en soi mais seulement montrent comment on peut utiliser les formules de transformation du plan.
Pour transformer une figure quelconque aussi complexe qu’elle soit, on doit transformer (évidemment dans une boucle) tous les points constituants la figure.
Il va de soi que plus le nombre de ces points est grand plus ça demande du temps pour les calculs.
J’espère que vous pouvez en sortir des belles réalisations.

Code:: ' ******************************************************************************
' TRANSFORMATIONS GENERALES DU PLAN
' PAR PAPYDALL
' ******************************************************************************

Init()
GUI()
end
' ******************************************************************************
' L'objet étudié ici est une petite fusée.
' Pour tout autre objet, il suffit de modifier en conséquence la ligne DATA
' Les données de la ligne DATA sont : le nombre de sommet (ici 11), viennent
' ensuite les coordonnées (X et Y) de tous les sommets (ici 11 paires de coordonnées)

SUB Init_Objet()
dim s : ' Nombre de sommets de l'objet étudié
read s : ' Lecture du nombre de sommets de l'objet étudié
dim xp(s + 1),yp(s + 1),i
' Lecture des coordonnées de l'objet
for i = 1 to s : read xp(i) : read yp(i) : next i
xp(s + 1) = xp(1) : yp(s + 1 ) = yp(1)
' Données spécifique de l'objet
data 11, 5,7,4,6,4,5,3,4,4,4,4,3,6,3,6,4,7,4,6,5,6,6
END_SUB
' ******************************************************************************
SUB Init()
label clic
dim M,N : ' coordonnées du point quelconque (0,0 si c'est l'origine)
dim rep$
dim pi,rad : pi = 4*atn(1) : rad = pi/180
dim theta : ' angle de rotation
dim A,B,C,D,P,Q : ' termes de la matrice
dim w1,w2,w3,w4 : ' coordonnées de la fenêtre de vision (window)
dim v1,v2,v3,v4 : ' coordonnées de la cloture (viewport)
dim t8,u8,t9,v8, p9,q9,x6,y6,x5,y5, a8,a9,b8,b9,w$
dim x1,y1,m1,u,v,x,y, Typ_Transf
width 0,screen_x-400 : height 0, screen_y-200
caption 0,"TRANSFORMATIONS GENERALES DU PLAN"
application_title "TRANSFORMATIONS GENERALES DU PLAN"
Init_Objet() : viewport()
END_SUB
' ******************************************************************************
SUB GUI()
' ---------
container 1 : top 1,50 : left 1,50 : width 1,width(0)-100 : height 1,600
alpha 3 : parent 3,1 : top 3,50 : left 3,50 : font_bold 3
caption 3,"VOULEZ-VOUS UNE TRANSFORMATION ..."

container_option 10: parent 10,1 : top 10,100 : left 10,20 : width 10,420
height 10,70 : font_bold 10
option 11 : parent 11,10 : top 11,10 : left 11,5 : width 11,400
caption 11,"PAR RAPPORT A L'ORIGINE (0,0)"
option 12 : parent 12,10 : top 12,40 : left 12,5 : width 12,400
caption 12,"PAR RAPPORT A UN POINT QUELCONQUE (M,N)"
on_click 11,clic : ' Type_Transformation
on_click 12,clic : ' Type_Transformation
' Coordonnées de l'origine(0,0)
alpha 20 : parent 20,1 : top 20,110 : left 20,450 : font_bold 20
' Coordonnée du point(M,N)
alpha 21 : parent 21,1 : top 21,140 : left 21,450 : font_bold 21
' -----------------
' Transformations par rapport à l'origine
container_option 30 : parent 30,1 : top 30,200 : left 30,20 : width 30,420
height 30,130 : font_bold 30 : hide 30
option 31 : parent 31,30 : top 31,10 : left 31,5 : width 31, 400
caption 31,"ROTATION" : on_click 31,clic : ' Saisie_Angle_Rotation
option 32 : parent 32,30 : top 32,40 : left 32,5 : width 32,400
caption 32,"CHANGEMENT D'ECHELLE" : on_click 32,clic : ' Saisie_Echelle
option 33 : parent 33,30 : top 33,70 : left 33,5 : width 33,400
caption 33,"SYMETRIE" : on_click 33,clic : ' Saisie_Symetrie
option 34 : parent 34,30 : top 34,100: left 34,5 : width 34,400
caption 34,"CISAILLEMENT" : on_click 34,clic :' Saisie_Cisaillement
' -----------------
' Transformations par rapport à un point quelconque
container_option 40 : parent 40,1 : top 40,200 : left 40,20 : width 40,420
height 40,130 : font_bold 40 : hide 40
option 41 : parent 41,40 : top 41,10 : left 41,5 : width 41, 400
caption 41,"ROTATION" : on_click 41,clic : ' Saisie_Angle_Rotation
option 42 : parent 42,40 : top 42,40 : left 42,5 : width 42,400
caption 42,"HOMOTHETIE" : on_click 42,clic : ' Saisie_Homothetie
option 43 : parent 43,40 : top 43,70 : left 43,5 : width 43,400
caption 43,"SYMETRIE" : on_click 43,clic : ' Saisie_Symetrie
' -----------------
' Angle de rotation Theta
alpha 50 : parent 50,1 : top 50,210 : left 50,450 : font_bold 50
' Cangement d'échelle selon X
alpha 51 : parent 51,1 : top 51,230 : left 51,450 : font_bold 51
' Cangement d'échelle selon Y
alpha 52 : parent 52,1 : top 52,250 : left 52,450 : font_bold 52
' --------------------
' Les symétrie
container_option 60 : parent 60,1 : top 60,200 : left 60,450 : width 60,130
option 61 : parent 61,60 : top 61,10 : left 61,5 : width 61,120 : caption 61,"SELON L'AXE X"
option 62 : parent 62,60 : top 62,40 : left 62,5 : width 62,120 : caption 62,"SELON L'AXE Y"
option 63 : parent 63,60 : top 63,70 : left 63,5 : width 63,120 : caption 63,"SELON L'ORIGINE"
hide 60
on_click 61,clic : ' Symetrie_Axe_X
on_click 62,clic : ' Symetrie_Axe_Y :
on_click 63,clic : ' Symetrie_Origine
' ----------------------
' Form pour les tracés
form 100 : width 100, 800 : height 100, 600 :hide 100 : caption 100,"GRAPHIQUE"
button 101 : parent 101,100 : top 101,500 : left 101,100 : caption 101,"Retour"
on_click 101,clic
' -----------------------
button 200 : parent 200,1 : top 200,400 : left 200,100 : caption 200,"Quitter"
on_click 200,clic
END_SUB
' ******************************************************************************
clic:
if clicked(11) > 0 or clicked(12) > 0 then Type_Transformation() : return
if clicked(31) > 0 or clicked(41) > 0 then Saisie_Angle_Rotation() : return
if clicked(32) > 0 then Saisie_Echelle() : return
if clicked(33) > 0 or clicked(43) > 0 then Saisie_Symetrie() : return
if clicked(34) > 0 then Saisie_Cisaillement() : return
if clicked(42) > 0 then Saisie_Homothetie() : return
if clicked(61) > 0 then Symetrie_Axe_X() : return
if clicked(62) > 0 then Symetrie_Axe_Y() : return
if clicked(63) > 0 then Symetrie_Origine() : return
if clicked(101)> 0 then hide 100 : return
if clicked(200) > 0 then terminate
return
' ******************************************************************************
SUB Type_Transformation()
hide 20 : hide 21 : hide 30 : hide 40 : hide 60
if checked(11) > 0
M = 0 : N = 0 : ' ramener le point à l'origine
caption 20,"M = 0" : caption 21,"N = 0"
show 20 : show 21 : show 30 : hide 40
Typ_Transf = 1
end_if

if checked(12) > 0 : ' Fournir les coordonnées du point
repeat
rep$ = message_input$("Abscisse M de ce point", "M = " , "")
until numeric(rep$) > 0
M = val(rep$)
repeat
rep$ = message_input$("Ordonnée N de ce point", "N = " , "")
until numeric(rep$) > 0
N = val(rep$)
caption 20,"M = " + str$(M) : caption 21,"N = " + str$(N)
show 20 : show 21 : show 40 : hide 30
Typ_Transf = 2
end_if
END_SUB
' ******************************************************************************
SUB Saisie_Angle_Rotation()
caption 50,"" : caption 51,"" : caption 52,"" : hide 60
repeat
rep$ = message_input$("Angle de rotation en degrés", "Theta = " , "")
until numeric(rep$) > 0
Theta = val(rep$) : caption 50,"THETA = " + str$(Theta) +" °"
Theta = Theta*rad : A = cos(Theta) : B = sin(Theta) : C = B : D = A
Recherche_Fenetre_Provisoire()
END_SUB
' ******************************************************************************
SUB Saisie_Echelle()
B = 0 : C = 0 : caption 50,"" : caption 51,"" : caption 52,"" : hide 60
repeat
rep$ = message_input$("ECHELLE SELON X","A =","")
until numeric(rep$) > 0
A = val(rep$) : caption 51,"A = " + rep$ + " B = 0"

repeat
rep$ = message_input$("ECHELLE SELON Y","D =","")
until numeric(rep$) > 0
D = val(rep$) : caption 52,"C = 0 D = " + str$(D)
Recherche_Fenetre_Provisoire()
END_SUB

' ******************************************************************************
SUB Saisie_Symetrie()
show 60
END_SUB
' ******************************************************************************
SUB Saisie_Cisaillement()
A = 1 : D = 1 : caption 50,"" : caption 51,"" : caption 52,"" : hide 60
repeat
rep$ = message_input$("Cisaillement","B =","")
until numeric(rep$) > 0
B = val(rep$) : caption 51,"A = 1" + " B = " + str$(B)
repeat
rep$ = message_input$("Cisaillement","C =","")
until numeric(rep$) > 0
C = val(rep$) : caption 52,"C = "+ str$(c) + " D = 1"
Recherche_Fenetre_Provisoire()
END_SUB
' ******************************************************************************
SUB Saisie_Homothetie()
caption 50,"" : caption 51,"" : caption 52,"" : hide 60
repeat
rep$ = message_input$("Rapport d'homothétie","A =","")
until numeric(rep$) > 0
A = val(rep$) : B = 0 : C = 0 : D = A
caption 51,"A = " + str$(A) + " B = 0"
caption 52,"C = 0 " + " D = " + str$(D)
Recherche_Fenetre_Provisoire()
END_SUB
' ******************************************************************************
SUB Symetrie_Axe_X()
' Termes de la matrice de symétrie par rapport à l'axe X
A = 1 : B = 0 : C = 0 : D = -1
Recherche_Fenetre_Provisoire()
END_SUB
' ******************************************************************************
SUB Symetrie_Axe_Y()
' Termes de la matrice de symétrie par rapport à l'axe Y
A = -1 : B = 0 : C = 0 : D = 1
Recherche_Fenetre_Provisoire()
END_SUB
' ******************************************************************************
SUB Symetrie_Origine()
' Termes de la matrice de symétrie par rapport à l'origine
A = -1 : B = 0 : C = 0 : D = -1
Recherche_Fenetre_Provisoire()
END_SUb
' ******************************************************************************
' recherche de la fenêtre provisoire
SUB Recherche_Fenetre_Provisoire()
dim_local i, m1,x1,y1
w1 = power(10,20) : w2 = 0-power(10,20)
w3 = power(10,20) : w4 = 0-power(10,20)
P = 0-M*A+N*C+M : Q = 0-M*B-N*D+N
' On applique la transformation à tous les points de l'objet afin de déterminer
' les abscisses et les ordonnées extremum qui nous fournirons la fenêtre w1,w2,w3,w4
for i = 1 to s
x1 = xp(i) : y1 = yp(i) : Recherche_Fenetre(x1,y1)
x1 = a*xp(i)-c*yp(i)+ P : y1 = b*xp(i)+d*yp(i)+ Q: Recherche_Fenetre(x1,y1)
next i
' M1 contient le maximum des w, il sert à obtenir une fenêtre carrée et une base orthonormée
m1 = abs(w1)
if m1 < abs(w2) then m1 = abs(w2)
if m1 < abs(w3) then m1 = abs(w3)
if m1 < abs(w4) then m1 = abs(w4)
w1 = 0-m1 : w2 = m1 : w3 = 0-m1 : w4 = m1
go()
END_SUB
' ******************************************************************************
' Initialiser la clôture
SUB Viewport()

read v1 : read v2 : read v3 : read v4
data 300,550,100,350 :' choix d'une clôture carrée afin d'éviter les distorsions
END_SUB

' ******************************************************************************
' La variable w$ peut prendre l'une de 2 valeurs "U" pour UP ou "D" pour DOWN
' si W$ = "U", on se déplace plume levée (sans laisser de trace) c.a.d 2D_POLY_FROM
' Si w$ = "D", on se deplace plume baissée ( en dessinant le trait) c.a.d 2D_POLY_TO
SUB Go()
dim_local x,y,w$,i
show 100 : 2d_target_is 100 : 2d_pen_color 0,0,0
' Tracer et graduer les axes de 1 en 1
Coord_Ecran() : Tracer_Axes() : Graduer_Axes(1,1)
' Tracer la figure donnée
x = xp(1) : y = yp(1) : w$ = "U" : Projection(x,y,w$) : w$ = "D"
for i = 2 to s+1
x = xp(i) : y = yp(i) : Projection(x,y,w$)
next i
' Tracer la figure transformée
2d_pen_color 255,0,0 : x = a*xp(1)-c*yp(1)+P: y = b*xp(1)+d*yp(1)+Q
w$ = "U" : Projection(x,y,w$) : w$ = "D"
for i = 2 to s+1
x = a*xp(i)-c*yp(i)+ P : y = b*xp(i)+d*yp(i)+ Q :Projection(x,y,w$)
next i
if Typ_transf = 2
x = M : y = N : w$ = "U" : projection(x,y,w$)
end_if

Affiche() : ' Afficher la matrice de transformation
END_SUB
' ******************************************************************************
' recherche fenêtre
SUB Recherche_Fenetre(x1,y1)
if x1 < w1 then w1 = x1
if x1 > w2 then w2 = x1
if y1 < w3 then w3 = y1
if y1 > w4 then w4 = y1
END_SUB

' ******************************************************************************
' Formules de passage des coordonnées utilisateur aux coordonnées écran
SUB Coord_Ecran()
a8 = (v2-v1)/(w2-w1) : b8 = (v1*w2-v2*w1)/(w2-w1)
a9 = (v4-v3)/(w4-w3) : b9 = (v3*w4-v4*w3)/(w4-w3)
END_SUB
' ******************************************************************************
SUB Graduer_Axes(u,v)
dim_local w$
t8 = 0.02 * (w2-w1) : t9 = 0.02*(w4-w3)
u8 = ((p9-w1)/u - int((p9-w1)/u))*u : v8 = ((q9-w3)/v - int((q9-w3)/v))*v
for x6 = w1+u8 to w2 step u
y6 = q9 : w$ = "U" : Tracer(w$) : y6 = q9+t9 : w$ = "D" : Tracer(w$)
next x6
for y6 = w3+v8 to w4 step v
x6 = p9 : w$ = "U" : Tracer(w$) : x6 = p9 + t8 : w$ = "D" : Tracer(w$)
next y6

END_SUB
' ******************************************************************************
' projection + tracer
SUB Projection(x,y,w$)
x6 = x : y6 = y : Tracer(w$)
END_SUB

' ******************************************************************************
' tracé des axes
SUB Tracer_Axes()
dim_local w$
p9 = w1 : q9 = w3
if w1 < 0 and w2 > 0 then p9 = 0
if w3 < 0 and w4 > 0 then q9 = 0
x6 = w1 : y6 = q9 : w$ = "U" : Tracer(w$)
x6 = w2 : w$ = "D" : Tracer(w$)
x6 = p9 : y6 = w3 : w$ = "U" : Tracer(w$)
y6 = w4 : w$ = "D" : Tracer(w$)
END_SUB
' ******************************************************************************
SUB Tracer(w$)
x5 = a8*x6+b8 : y5 = 400 - (a9*y6+b9)
if w$ = "U" then 2d_poly_from x5,y5 : exit_sub
2d_poly_to x5,y5
END_SUB

' ******************************************************************************
SUB Affiche()
print_target_is 100
print : print : print " MATRICE DE TRANSFORMATION" : print
print " A = ";A;" ";"B = ";B
print " C = ";C;" ";"D = ";D
print " P = ";P;" ";"Q = ";Q
END_SUB
' ******************************************************************************

bonjour a tous
je viens de prendre connaissance de ce merveilleur cour de maths qui me rappel de longues nuit d'insomnie.
Là c'est nettement plus claire qu'a l'epoque sunny

merci papydall
il me reste une difficultée car je ne maitrise pas assé Panoramic.
Je ne parviens pas a executer tes programmes, a chaque fois une erreur " illegal fonction in line 6 " apparait (sur le RUN)
quelqu un peut il m'expliquer confused

?

merci a tous
je viens de regler le probleme en installant la derniere version
bounce

» Bases mathématiques du graphisme à 3 dimensions
» Graphisme
» bases de données SQL
» Graphisme inédit
» CONVERSION DE BASES